diff --git a/fastkml/containers.py b/fastkml/containers.py
new file mode 100644
index 00000000..b0285a6c
--- /dev/null
+++ b/fastkml/containers.py
@@ -0,0 +1,202 @@
+"""
+Container classes for KML elements.
+"""
+import logging
+import urllib.parse as urlparse
+from typing import Dict
+from typing import Iterator
+from typing import List
+from typing import Optional
+from typing import Union
+
+from fastkml import gx
+from fastkml.data import Schema
+from fastkml.enums import Verbosity
+from fastkml.features import Placemark
+from fastkml.features import _Feature
+from fastkml.geometry import LinearRing
+from fastkml.geometry import LineString
+from fastkml.geometry import MultiGeometry
+from fastkml.geometry import Point
+from fastkml.geometry import Polygon
+from fastkml.overlays import _Overlay
+from fastkml.styles import Style
+from fastkml.styles import StyleMap
+from fastkml.types import Element
+
+logger = logging.getLogger(__name__)
+
+KmlGeometry = Union[
+    Point,
+    LineString,
+    LinearRing,
+    Polygon,
+    MultiGeometry,
+    gx.MultiTrack,
+    gx.Track,
+]
+
+
+class _Container(_Feature):
+    """
+    abstract element; do not create
+    A Container element holds one or more Features and allows the
+    creation of nested hierarchies.
+    subclasses are:
+    Document,
+    Folder.
+    """
+
+    _features = []
+
+    def __init__(
+        self,
+        ns: Optional[str] = None,
+        name_spaces: Optional[Dict[str, str]] = None,
+        id: Optional[str] = None,
+        target_id: Optional[str] = None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        styles: Optional[List[Style]] = None,
+        style_url: Optional[str] = None,
+        features: None = None,
+    ) -> None:
+        super().__init__(
+            ns=ns,
+            name_spaces=name_spaces,
+            id=id,
+            target_id=target_id,
+            name=name,
+            description=description,
+            styles=styles,
+            style_url=style_url,
+        )
+        self._features = features or []
+
+    def features(self) -> Iterator[_Feature]:
+        """Iterate over features."""
+        for feature in self._features:
+            if isinstance(feature, (Folder, Placemark, Document, _Overlay)):
+                yield feature
+            else:
+                msg = (
+                    "Features must be instances of "
+                    "(Folder, Placemark, Document, Overlay)"
+                )
+                raise TypeError(
+                    msg,
+                )
+
+    def etree_element(
+        self,
+        precision: Optional[int] = None,
+        verbosity: Verbosity = Verbosity.normal,
+    ) -> Element:
+        element = super().etree_element(precision=precision, verbosity=verbosity)
+        for feature in self.features():
+            element.append(feature.etree_element())
+        return element
+
+    def append(self, kmlobj: _Feature) -> None:
+        """Append a feature."""
+        if id(kmlobj) == id(self):
+            msg = "Cannot append self"
+            raise ValueError(msg)
+        if isinstance(kmlobj, (Folder, Placemark, Document, _Overlay)):
+            self._features.append(kmlobj)
+        else:
+            msg = "Features must be instances of (Folder, Placemark, Document, Overlay)"
+            raise TypeError(
+                msg,
+            )
+
+
+class Folder(_Container):
+    """
+    A Folder is used to arrange other Features hierarchically
+    (Folders, Placemarks, #NetworkLinks, or #Overlays).
+    """
+
+    __name__ = "Folder"
+
+    def from_element(self, element: Element) -> None:
+        super().from_element(element)
+        folders = element.findall(f"{self.ns}Folder")
+        for folder in folders:
+            feature = Folder(self.ns)
+            feature.from_element(folder)
+            self.append(feature)
+        placemarks = element.findall(f"{self.ns}Placemark")
+        for placemark in placemarks:
+            feature = Placemark(self.ns)
+            feature.from_element(placemark)
+            self.append(feature)
+        documents = element.findall(f"{self.ns}Document")
+        for document in documents:
+            feature = Document(self.ns)
+            feature.from_element(document)
+            self.append(feature)
+
+
+class Document(_Container):
+    """
+    A Document is a container for features and styles. This element is
+    required if your KML file uses shared styles or schemata for typed
+    extended data.
+    """
+
+    __name__ = "Document"
+    _schemata = None
+
+    def schemata(self) -> Iterator["Schema"]:
+        if self._schemata:
+            yield from self._schemata
+
+    def append_schema(self, schema: "Schema") -> None:
+        if self._schemata is None:
+            self._schemata = []
+        if isinstance(schema, Schema):
+            self._schemata.append(schema)
+        else:
+            s = Schema(schema)
+            self._schemata.append(s)
+
+    def from_element(self, element: Element, strict: bool = False) -> None:
+        super().from_element(element)
+        documents = element.findall(f"{self.ns}Document")
+        for document in documents:
+            feature = Document(self.ns)
+            feature.from_element(document)
+            self.append(feature)
+        folders = element.findall(f"{self.ns}Folder")
+        for folder in folders:
+            feature = Folder(self.ns)
+            feature.from_element(folder)
+            self.append(feature)
+        placemarks = element.findall(f"{self.ns}Placemark")
+        for placemark in placemarks:
+            feature = Placemark(self.ns)
+            feature.from_element(placemark)
+            self.append(feature)
+        schemata = element.findall(f"{self.ns}Schema")
+        for schema in schemata:
+            s = Schema.class_from_element(ns=self.ns, element=schema, strict=strict)
+            self.append_schema(s)
+
+    def etree_element(
+        self,
+        precision: Optional[int] = None,
+        verbosity: Verbosity = Verbosity.normal,
+    ) -> Element:
+        element = super().etree_element(precision=precision, verbosity=verbosity)
+        if self._schemata is not None:
+            for schema in self._schemata:
+                element.append(schema.etree_element())
+        return element
+
+    def get_style_by_url(self, style_url: str) -> Optional[Union[Style, StyleMap]]:
+        id = urlparse.urlparse(style_url).fragment
+        for style in self.styles():
+            if style.id == id:
+                return style
+        return None
diff --git a/fastkml/features.py b/fastkml/features.py
new file mode 100644
index 00000000..b911f359
--- /dev/null
+++ b/fastkml/features.py
@@ -0,0 +1,634 @@
+"""
+Feature base, Placemark and NetworkLink.
+
+These are the objects that can be added to a KML file.
+"""
+
+import logging
+from datetime import datetime
+from typing import Any
+from typing import Dict
+from typing import Iterator
+from typing import List
+from typing import Optional
+from typing import Union
+
+from fastkml import atom
+from fastkml import config
+from fastkml import gx
+from fastkml.base import _BaseObject
+from fastkml.data import ExtendedData
+from fastkml.enums import Verbosity
+from fastkml.geometry import AnyGeometryType
+from fastkml.geometry import LinearRing
+from fastkml.geometry import LineString
+from fastkml.geometry import MultiGeometry
+from fastkml.geometry import Point
+from fastkml.geometry import Polygon
+from fastkml.mixins import TimeMixin
+from fastkml.styles import Style
+from fastkml.styles import StyleMap
+from fastkml.styles import StyleUrl
+from fastkml.styles import _StyleSelector
+from fastkml.times import TimeSpan
+from fastkml.times import TimeStamp
+from fastkml.types import Element
+from fastkml.views import Camera
+from fastkml.views import LookAt
+
+logger = logging.getLogger(__name__)
+
+KmlGeometry = Union[
+    Point,
+    LineString,
+    LinearRing,
+    Polygon,
+    MultiGeometry,
+    gx.MultiTrack,
+    gx.Track,
+]
+
+
+class _Feature(TimeMixin, _BaseObject):
+    """
+    abstract element; do not create
+    subclasses are:
+        * Container (Document, Folder)
+        * Placemark
+        * Overlay
+    Not Implemented Yet:
+        * NetworkLink.
+    """
+
+    name: Optional[str]
+    # User-defined text displayed in the 3D viewer as the label for the
+    # object (for example, for a Placemark, Folder, or NetworkLink).
+
+    visibility: Optional[bool]
+    # Boolean value. Specifies whether the feature is drawn in the 3D
+    # viewer when it is initially loaded. In order for a feature to be
+    # visible, the <visibility> tag of all its ancestors must also be
+    # set to 1.
+
+    isopen: Optional[bool]
+    # Boolean value. Specifies whether a Document or Folder appears
+    # closed or open when first loaded into the Places panel.
+    # 0=collapsed (the default), 1=expanded.
+
+    _atom_author: Optional[atom.Author]
+    # KML 2.2 supports new elements for including data about the author
+    # and related website in your KML file. This information is displayed
+    # in geo search results, both in Earth browsers such as Google Earth,
+    # and in other applications such as Google Maps.
+
+    _atom_link: Optional[atom.Link]
+    # Specifies the URL of the website containing this KML or KMZ file.
+
+    _address: Optional[str]
+    # A string value representing an unstructured address written as a
+    # standard street, city, state address, and/or as a postal code.
+    # You can use the <address> tag to specify the location of a point
+    # instead of using latitude and longitude coordinates.
+
+    _phone_number: Optional[str]
+    # A string value representing a telephone number.
+    # This element is used by Google Maps Mobile only.
+
+    _snippet: Optional[Union[str, Dict[str, Any]]]
+    # _snippet is either a tuple of a string Snippet.text and an integer
+    # Snippet.maxLines or a string
+    #
+    # A short description of the feature. In Google Earth, this
+    # description is displayed in the Places panel under the name of the
+    # feature. If a Snippet is not supplied, the first two lines of
+    # the <description> are used. In Google Earth, if a Placemark
+    # contains both a description and a Snippet, the <Snippet> appears
+    # beneath the Placemark in the Places panel, and the <description>
+    # appears in the Placemark's description balloon. This tag does not
+    # support HTML markup. <Snippet> has a maxLines attribute, an integer
+    # that specifies the maximum number of lines to display.
+
+    description: Optional[str]
+    # User-supplied content that appears in the description balloon.
+
+    _style_url: Optional[Union[Style, StyleMap]]
+    # URL of a <Style> or <StyleMap> defined in a Document.
+    # If the style is in the same file, use a # reference.
+    # If the style is defined in an external file, use a full URL
+    # along with # referencing.
+
+    _styles: List[Union[Style, StyleMap]]
+    # One or more Styles and StyleMaps can be defined to customize the
+    # appearance of any element derived from Feature or of the Geometry
+    # in a Placemark.
+    # A style defined within a Feature is called an "inline style" and
+    # applies only to the Feature that contains it. A style defined as
+    # the child of a <Document> is called a "shared style." A shared
+    # style must have an id defined for it. This id is referenced by one
+    # or more Features within the <Document>. In cases where a style
+    # element is defined both in a shared style and in an inline style
+    # for a Feature—that is, a Folder, GroundOverlay, NetworkLink,
+    # Placemark, or ScreenOverlay—the value for the Feature's inline
+    # style takes precedence over the value for the shared style.
+
+    _timespan: Optional[TimeSpan]
+    # Associates this Feature with a period of time.
+    _timestamp: Optional[TimeStamp]
+    # Associates this Feature with a point in time.
+
+    _camera: Optional[Camera]
+
+    _look_at: Optional[LookAt]
+
+    # TODO Region = None
+    # Features and geometry associated with a Region are drawn only when
+    # the Region is active.
+
+    # TODO ExtendedData = None
+    # Allows you to add custom data to a KML file. This data can be
+    # (1) data that references an external XML schema,
+    # (2) untyped data/value pairs, or
+    # (3) typed data.
+    # A given KML Feature can contain a combination of these types of
+    # custom data.
+    #
+    # (2) is already implemented, see UntypedExtendedData
+    #
+    # <Metadata> (deprecated in KML 2.2; use <ExtendedData> instead)
+    extended_data: Optional[ExtendedData]
+
+    def __init__(
+        self,
+        ns: Optional[str] = None,
+        name_spaces: Optional[Dict[str, str]] = None,
+        id: Optional[str] = None,
+        target_id: Optional[str] = None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        snippet: Optional[Union[str, Dict[str, Any]]] = None,
+        atom_author: Optional[atom.Author] = None,
+        atom_link: Optional[atom.Link] = None,
+        visibility: Optional[bool] = None,
+        isopen: Optional[bool] = None,
+        styles: Optional[List[Style]] = None,
+        style_url: Optional[str] = None,
+        extended_data: None = None,
+        camera: Optional[Camera] = None,
+        look_at: Optional[LookAt] = None,
+        address: Optional[str] = None,
+        phone_number: Optional[str] = None,
+    ) -> None:
+        super().__init__(ns=ns, name_spaces=name_spaces, id=id, target_id=target_id)
+        self.name = name
+        self.description = description
+        self.style_url = style_url
+        self._styles = []
+        self._camera = camera
+        self._look_at = look_at
+        self.visibility = visibility
+        self.isopen = isopen
+        self.snippet = snippet
+        self._atom_author = atom_author
+        self._atom_link = atom_link
+        self.address = address
+        self.phone_number = phone_number
+        if styles:
+            for style in styles:
+                self.append_style(style)
+        self.extended_data = extended_data
+
+    @property
+    def style_url(self) -> Optional[str]:
+        """
+        Returns the url only, not a full StyleUrl object.
+        if you need the full StyleUrl object use _style_url.
+        """
+        if isinstance(self._style_url, StyleUrl):
+            return self._style_url.url
+        return None
+
+    @style_url.setter
+    def style_url(self, styleurl: Union[str, StyleUrl, None]) -> None:
+        """You may pass a StyleUrl Object, a string or None."""
+        if isinstance(styleurl, StyleUrl):
+            self._style_url = styleurl
+        elif isinstance(styleurl, str):
+            s = StyleUrl(self.ns, url=styleurl)
+            self._style_url = s
+        elif styleurl is None:
+            self._style_url = None
+        else:
+            raise ValueError
+
+    @property
+    def camera(self):
+        return self._camera
+
+    @camera.setter
+    def camera(self, camera) -> None:
+        if isinstance(camera, Camera):
+            self._camera = camera
+
+    @property
+    def look_at(self) -> datetime:
+        return self._look_at
+
+    @look_at.setter
+    def look_at(self, look_at) -> None:
+        if isinstance(look_at, LookAt):
+            self._look_at = look_at
+
+    @property
+    def link(self):
+        return self._atom_link.href
+
+    @link.setter
+    def link(self, url) -> None:
+        if isinstance(url, str):
+            self._atom_link = atom.Link(href=url)
+        elif isinstance(url, atom.Link):
+            self._atom_link = url
+        elif url is None:
+            self._atom_link = None
+        else:
+            raise TypeError
+
+    @property
+    def author(self) -> None:
+        if self._atom_author:
+            return self._atom_author.name
+        return None
+
+    @author.setter
+    def author(self, name) -> None:
+        if isinstance(name, atom.Author):
+            self._atom_author = name
+        elif isinstance(name, str):
+            if self._atom_author is None:
+                self._atom_author = atom.Author(ns=config.ATOMNS, name=name)
+            else:
+                self._atom_author.name = name
+        elif name is None:
+            self._atom_author = None
+        else:
+            raise TypeError
+
+    def append_style(self, style: Union[Style, StyleMap]) -> None:
+        """Append a style to the feature."""
+        if isinstance(style, _StyleSelector):
+            self._styles.append(style)
+        else:
+            raise TypeError
+
+    def styles(self) -> Iterator[Union[Style, StyleMap]]:
+        """Iterate over the styles of this feature."""
+        for style in self._styles:
+            if isinstance(style, _StyleSelector):
+                yield style
+            else:
+                raise TypeError
+
+    @property
+    def snippet(self) -> Optional[Dict[str, Any]]:
+        if not self._snippet:
+            return None
+        if isinstance(self._snippet, dict):
+            text = self._snippet.get("text")
+            if text:
+                assert isinstance(text, str)
+                max_lines = self._snippet.get("maxLines", None)
+                if max_lines is None:
+                    return {"text": text}
+                elif int(max_lines) > 0:
+                    # if maxLines <=0 ignore it
+                    return {"text": text, "maxLines": max_lines}
+                return None
+            return None
+        elif isinstance(self._snippet, str):
+            return self._snippet
+        else:
+            msg = "Snippet must be dict of {'text':t, 'maxLines':i} or string"
+            raise ValueError(
+                msg,
+            )
+
+    @snippet.setter
+    def snippet(self, snip=None) -> None:
+        self._snippet = {}
+        if isinstance(snip, dict):
+            self._snippet["text"] = snip.get("text")
+            max_lines = snip.get("maxLines")
+            if max_lines is not None:
+                self._snippet["maxLines"] = int(snip["maxLines"])
+        elif isinstance(snip, str):
+            self._snippet["text"] = snip
+        elif snip is None:
+            self._snippet = None
+        else:
+            msg = "Snippet must be dict of {'text':t, 'maxLines':i} or string"
+            raise ValueError(
+                msg,
+            )
+
+    @property
+    def address(self) -> None:
+        if self._address:
+            return self._address
+        return None
+
+    @address.setter
+    def address(self, address) -> None:
+        if isinstance(address, str):
+            self._address = address
+        elif address is None:
+            self._address = None
+        else:
+            raise ValueError
+
+    @property
+    def phone_number(self) -> None:
+        if self._phone_number:
+            return self._phone_number
+        return None
+
+    @phone_number.setter
+    def phone_number(self, phone_number) -> None:
+        if isinstance(phone_number, str):
+            self._phone_number = phone_number
+        elif phone_number is None:
+            self._phone_number = None
+        else:
+            raise ValueError
+
+    def etree_element(
+        self,
+        precision: Optional[int] = None,
+        verbosity: Verbosity = Verbosity.normal,
+    ) -> Element:
+        element = super().etree_element(precision=precision, verbosity=verbosity)
+        if self.name:
+            name = config.etree.SubElement(element, f"{self.ns}name")
+            name.text = self.name
+        if self.description:
+            description = config.etree.SubElement(element, f"{self.ns}description")
+            description.text = self.description
+        if (self.camera is not None) and (self.look_at is not None):
+            msg = "Either Camera or LookAt can be defined, not both"
+            raise ValueError(msg)
+        if self.camera is not None:
+            element.append(self._camera.etree_element())
+        elif self.look_at is not None:
+            element.append(self._look_at.etree_element())
+        if self.visibility is not None:
+            visibility = config.etree.SubElement(element, f"{self.ns}visibility")
+            visibility.text = str(self.visibility)
+        if self.isopen:
+            isopen = config.etree.SubElement(element, f"{self.ns}open")
+            isopen.text = str(self.isopen)
+        if self._style_url is not None:
+            element.append(self._style_url.etree_element())
+        for style in self.styles():
+            element.append(style.etree_element())
+        if self.snippet:
+            snippet = config.etree.SubElement(element, f"{self.ns}Snippet")
+            if isinstance(self.snippet, str):
+                snippet.text = self.snippet
+            else:
+                assert isinstance(self.snippet["text"], str)
+                snippet.text = self.snippet["text"]
+                if self.snippet.get("maxLines"):
+                    snippet.set("maxLines", str(self.snippet["maxLines"]))
+        if (self._timespan is not None) and (self._timestamp is not None):
+            msg = "Either Timestamp or Timespan can be defined, not both"
+            raise ValueError(msg)
+        elif self._timespan is not None:
+            element.append(self._timespan.etree_element())
+        elif self._timestamp is not None:
+            element.append(self._timestamp.etree_element())
+        if self._atom_link is not None:
+            element.append(self._atom_link.etree_element())
+        if self._atom_author is not None:
+            element.append(self._atom_author.etree_element())
+        if self.extended_data is not None:
+            element.append(self.extended_data.etree_element())
+        if self._address is not None:
+            address = config.etree.SubElement(element, f"{self.ns}address")
+            address.text = self._address
+        if self._phone_number is not None:
+            phone_number = config.etree.SubElement(element, f"{self.ns}phoneNumber")
+            phone_number.text = self._phone_number
+        return element
+
+    def from_element(self, element: Element, strict: bool = False) -> None:
+        super().from_element(element)
+        name = element.find(f"{self.ns}name")
+        if name is not None:
+            self.name = name.text
+        description = element.find(f"{self.ns}description")
+        if description is not None:
+            self.description = description.text
+        visibility = element.find(f"{self.ns}visibility")
+        if visibility is not None and visibility.text:
+            self.visibility = 1 if visibility.text in ["1", "true"] else 0
+        isopen = element.find(f"{self.ns}open")
+        if isopen is not None:
+            self.isopen = 1 if isopen.text in ["1", "true"] else 0
+        styles = element.findall(f"{self.ns}Style")
+        for style in styles:
+            s = Style.class_from_element(
+                ns=self.ns,
+                name_spaces=self.name_spaces,
+                element=style,
+                strict=strict,
+            )
+            self.append_style(s)
+        styles = element.findall(f"{self.ns}StyleMap")
+        for style in styles:
+            s = StyleMap.class_from_element(
+                ns=self.ns,
+                name_spaces=self.name_spaces,
+                element=style,
+                strict=strict,
+            )
+            self.append_style(s)
+        style_url = element.find(f"{self.ns}styleUrl")
+        if style_url is not None:
+            self._style_url = StyleUrl.class_from_element(
+                ns=self.ns,
+                name_spaces=self.name_spaces,
+                element=style_url,
+                strict=strict,
+            )
+        snippet = element.find(f"{self.ns}Snippet")
+        if snippet is not None:
+            _snippet = {"text": snippet.text}
+            if snippet.get("maxLines"):
+                _snippet["maxLines"] = int(snippet.get("maxLines"))
+            self.snippet = _snippet
+        timespan = element.find(f"{self.ns}TimeSpan")
+        if timespan is not None:
+            self._timespan = TimeSpan.class_from_element(
+                ns=self.ns,
+                name_spaces=self.name_spaces,
+                element=timespan,
+                strict=strict,
+            )
+        timestamp = element.find(f"{self.ns}TimeStamp")
+        if timestamp is not None:
+            self._timestamp = TimeStamp.class_from_element(
+                ns=self.ns,
+                name_spaces=self.name_spaces,
+                element=timestamp,
+                strict=strict,
+            )
+        atom_link = element.find(f"{atom.NS}link")
+        if atom_link is not None:
+            self._atom_link = atom.Link.class_from_element(
+                ns=atom.NS,
+                name_spaces=self.name_spaces,
+                element=atom_link,
+                strict=strict,
+            )
+        atom_author = element.find(f"{atom.NS}author")
+        if atom_author is not None:
+            self._atom_author = atom.Author.class_from_element(
+                ns=atom.NS,
+                name_spaces=self.name_spaces,
+                element=atom_author,
+                strict=strict,
+            )
+        extended_data = element.find(f"{self.ns}ExtendedData")
+        if extended_data is not None:
+            self.extended_data = ExtendedData.class_from_element(
+                ns=self.ns,
+                element=extended_data,
+                strict=strict,
+            )
+        address = element.find(f"{self.ns}address")
+        if address is not None:
+            self.address = address.text
+        phone_number = element.find(f"{self.ns}phoneNumber")
+        if phone_number is not None:
+            self.phone_number = phone_number.text
+        camera = element.find(f"{self.ns}Camera")
+        if camera is not None:
+            s = Camera(self.ns)
+            s.from_element(camera)
+            self.camera = s
+
+
+class Placemark(_Feature):
+    """
+    A Placemark is a Feature with associated Geometry.
+    In Google Earth, a Placemark appears as a list item in the Places
+    panel. A Placemark with a Point has an icon associated with it that
+    marks a point on the Earth in the 3D viewer.
+    """
+
+    __name__ = "Placemark"
+    _geometry = None
+
+    def __init__(
+        self,
+        ns: Optional[str] = None,
+        name_spaces: Optional[Dict[str, str]] = None,
+        id: Optional[str] = None,
+        target_id: Optional[str] = None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        styles: Optional[List[Style]] = None,
+        style_url: Optional[str] = None,
+        extended_data: None = None,
+        geometry: Optional[KmlGeometry] = None,
+    ) -> None:
+        super().__init__(
+            ns=ns,
+            name_spaces=name_spaces,
+            id=id,
+            target_id=target_id,
+            name=name,
+            description=description,
+            styles=styles,
+            style_url=style_url,
+            extended_data=extended_data,
+        )
+        self._geometry = geometry
+
+    @property
+    def geometry(self) -> Optional[AnyGeometryType]:
+        if self._geometry is not None:
+            return self._geometry.geometry
+        return None
+
+    def from_element(self, element: Element, strict=False) -> None:
+        super().from_element(element)
+        point = element.find(f"{self.ns}Point")
+        if point is not None:
+            self._geometry = Point.class_from_element(
+                ns=self.ns,
+                element=point,
+                strict=strict,
+            )
+            return
+        line = element.find(f"{self.ns}LineString")
+        if line is not None:
+            self._geometry = LineString.class_from_element(
+                ns=self.ns,
+                element=line,
+                strict=strict,
+            )
+            return
+        polygon = element.find(f"{self.ns}Polygon")
+        if polygon is not None:
+            self._geometry = Polygon.class_from_element(
+                ns=self.ns,
+                element=polygon,
+                strict=strict,
+            )
+            return
+        linearring = element.find(f"{self.ns}LinearRing")
+        if linearring is not None:
+            self._geometry = LinearRing.class_from_element(
+                ns=self.ns,
+                element=linearring,
+                strict=strict,
+            )
+            return
+        multigeometry = element.find(f"{self.ns}MultiGeometry")
+        if multigeometry is not None:
+            self._geometry = MultiGeometry.class_from_element(
+                ns=self.ns,
+                element=multigeometry,
+                strict=strict,
+            )
+            return
+        track = element.find(f"{self.ns}Track")
+        if track is not None:
+            self._geometry = gx.Track.class_from_element(
+                ns=config.GXNS,
+                element=track,
+                strict=strict,
+            )
+            return
+        multitrack = element.find(f"{self.ns}MultiTrack")
+        if multitrack is not None:
+            self._geometry = gx.MultiTrack.class_from_element(
+                ns=config.GXNS,
+                element=multitrack,
+                strict=strict,
+            )
+            return
+        logger.warning("No geometries found")
+        logger.debug("Problem with element: %", config.etree.tostring(element))
+
+    def etree_element(
+        self,
+        precision: Optional[int] = None,
+        verbosity: Verbosity = Verbosity.normal,
+    ) -> Element:
+        element = super().etree_element(precision=precision, verbosity=verbosity)
+        if self._geometry is not None:
+            element.append(self._geometry.etree_element())
+        else:
+            logger.error("Object does not have a geometry")
+        return element
diff --git a/fastkml/kml.py b/fastkml/kml.py
index 4881406b..c8dae9da 100644
--- a/fastkml/kml.py
+++ b/fastkml/kml.py
@@ -25,1503 +25,24 @@
 
 """
 import logging
-import urllib.parse as urlparse
-from datetime import datetime
-from typing import Any
 from typing import Dict
 from typing import Iterable
 from typing import Iterator
-from typing import List
 from typing import Optional
 from typing import Union
 
-from fastkml import atom
 from fastkml import config
-from fastkml import gx
-from fastkml.base import _BaseObject
-from fastkml.data import ExtendedData
-from fastkml.data import Schema
-from fastkml.enums import GridOrigin
-from fastkml.enums import Shape
+from fastkml.containers import Document
+from fastkml.containers import Folder
 from fastkml.enums import Verbosity
-from fastkml.geometry import AnyGeometryType
-from fastkml.geometry import LinearRing
-from fastkml.geometry import LineString
-from fastkml.geometry import MultiGeometry
-from fastkml.geometry import Point
-from fastkml.geometry import Polygon
-from fastkml.links import Icon
-from fastkml.mixins import TimeMixin
-from fastkml.styles import Style
-from fastkml.styles import StyleMap
-from fastkml.styles import StyleUrl
-from fastkml.styles import _StyleSelector
-from fastkml.times import TimeSpan
-from fastkml.times import TimeStamp
+from fastkml.features import Placemark
+from fastkml.overlays import GroundOverlay
+from fastkml.overlays import PhotoOverlay
+from fastkml.overlays import _Overlay
 from fastkml.types import Element
-from fastkml.views import Camera
-from fastkml.views import LookAt
 
 logger = logging.getLogger(__name__)
 
-KmlGeometry = Union[
-    Point,
-    LineString,
-    LinearRing,
-    Polygon,
-    MultiGeometry,
-    gx.MultiTrack,
-    gx.Track,
-]
-
-
-class _Feature(TimeMixin, _BaseObject):
-    """
-    abstract element; do not create
-    subclasses are:
-        * Container (Document, Folder)
-        * Placemark
-        * Overlay
-    Not Implemented Yet:
-        * NetworkLink.
-    """
-
-    name: Optional[str]
-    # User-defined text displayed in the 3D viewer as the label for the
-    # object (for example, for a Placemark, Folder, or NetworkLink).
-
-    visibility: Optional[bool]
-    # Boolean value. Specifies whether the feature is drawn in the 3D
-    # viewer when it is initially loaded. In order for a feature to be
-    # visible, the <visibility> tag of all its ancestors must also be
-    # set to 1.
-
-    isopen: Optional[bool]
-    # Boolean value. Specifies whether a Document or Folder appears
-    # closed or open when first loaded into the Places panel.
-    # 0=collapsed (the default), 1=expanded.
-
-    _atom_author: Optional[atom.Author]
-    # KML 2.2 supports new elements for including data about the author
-    # and related website in your KML file. This information is displayed
-    # in geo search results, both in Earth browsers such as Google Earth,
-    # and in other applications such as Google Maps.
-
-    _atom_link: Optional[atom.Link]
-    # Specifies the URL of the website containing this KML or KMZ file.
-
-    _address: Optional[str]
-    # A string value representing an unstructured address written as a
-    # standard street, city, state address, and/or as a postal code.
-    # You can use the <address> tag to specify the location of a point
-    # instead of using latitude and longitude coordinates.
-
-    _phone_number: Optional[str]
-    # A string value representing a telephone number.
-    # This element is used by Google Maps Mobile only.
-
-    _snippet: Optional[Union[str, Dict[str, Any]]]
-    # _snippet is either a tuple of a string Snippet.text and an integer
-    # Snippet.maxLines or a string
-    #
-    # A short description of the feature. In Google Earth, this
-    # description is displayed in the Places panel under the name of the
-    # feature. If a Snippet is not supplied, the first two lines of
-    # the <description> are used. In Google Earth, if a Placemark
-    # contains both a description and a Snippet, the <Snippet> appears
-    # beneath the Placemark in the Places panel, and the <description>
-    # appears in the Placemark's description balloon. This tag does not
-    # support HTML markup. <Snippet> has a maxLines attribute, an integer
-    # that specifies the maximum number of lines to display.
-
-    description: Optional[str]
-    # User-supplied content that appears in the description balloon.
-
-    _style_url: Optional[Union[Style, StyleMap]]
-    # URL of a <Style> or <StyleMap> defined in a Document.
-    # If the style is in the same file, use a # reference.
-    # If the style is defined in an external file, use a full URL
-    # along with # referencing.
-
-    _styles: List[Union[Style, StyleMap]]
-    # One or more Styles and StyleMaps can be defined to customize the
-    # appearance of any element derived from Feature or of the Geometry
-    # in a Placemark.
-    # A style defined within a Feature is called an "inline style" and
-    # applies only to the Feature that contains it. A style defined as
-    # the child of a <Document> is called a "shared style." A shared
-    # style must have an id defined for it. This id is referenced by one
-    # or more Features within the <Document>. In cases where a style
-    # element is defined both in a shared style and in an inline style
-    # for a Feature—that is, a Folder, GroundOverlay, NetworkLink,
-    # Placemark, or ScreenOverlay—the value for the Feature's inline
-    # style takes precedence over the value for the shared style.
-
-    _timespan: Optional[TimeSpan]
-    # Associates this Feature with a period of time.
-    _timestamp: Optional[TimeStamp]
-    # Associates this Feature with a point in time.
-
-    _camera: Optional[Camera]
-
-    _look_at: Optional[LookAt]
-
-    # TODO Region = None
-    # Features and geometry associated with a Region are drawn only when
-    # the Region is active.
-
-    # TODO ExtendedData = None
-    # Allows you to add custom data to a KML file. This data can be
-    # (1) data that references an external XML schema,
-    # (2) untyped data/value pairs, or
-    # (3) typed data.
-    # A given KML Feature can contain a combination of these types of
-    # custom data.
-    #
-    # (2) is already implemented, see UntypedExtendedData
-    #
-    # <Metadata> (deprecated in KML 2.2; use <ExtendedData> instead)
-    extended_data: Optional[ExtendedData]
-
-    def __init__(
-        self,
-        ns: Optional[str] = None,
-        name_spaces: Optional[Dict[str, str]] = None,
-        id: Optional[str] = None,
-        target_id: Optional[str] = None,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        snippet: Optional[Union[str, Dict[str, Any]]] = None,
-        atom_author: Optional[atom.Author] = None,
-        atom_link: Optional[atom.Link] = None,
-        visibility: Optional[bool] = None,
-        isopen: Optional[bool] = None,
-        styles: Optional[List[Style]] = None,
-        style_url: Optional[str] = None,
-        extended_data: None = None,
-        camera: Optional[Camera] = None,
-        look_at: Optional[LookAt] = None,
-        address: Optional[str] = None,
-        phone_number: Optional[str] = None,
-    ) -> None:
-        super().__init__(ns=ns, name_spaces=name_spaces, id=id, target_id=target_id)
-        self.name = name
-        self.description = description
-        self.style_url = style_url
-        self._styles = []
-        self._camera = camera
-        self._look_at = look_at
-        self.visibility = visibility
-        self.isopen = isopen
-        self.snippet = snippet
-        self._atom_author = atom_author
-        self._atom_link = atom_link
-        self.address = address
-        self.phone_number = phone_number
-        if styles:
-            for style in styles:
-                self.append_style(style)
-        self.extended_data = extended_data
-
-    @property
-    def style_url(self) -> Optional[str]:
-        """
-        Returns the url only, not a full StyleUrl object.
-        if you need the full StyleUrl object use _style_url.
-        """
-        if isinstance(self._style_url, StyleUrl):
-            return self._style_url.url
-        return None
-
-    @style_url.setter
-    def style_url(self, styleurl: Union[str, StyleUrl, None]) -> None:
-        """You may pass a StyleUrl Object, a string or None."""
-        if isinstance(styleurl, StyleUrl):
-            self._style_url = styleurl
-        elif isinstance(styleurl, str):
-            s = StyleUrl(self.ns, url=styleurl)
-            self._style_url = s
-        elif styleurl is None:
-            self._style_url = None
-        else:
-            raise ValueError
-
-    @property
-    def camera(self):
-        return self._camera
-
-    @camera.setter
-    def camera(self, camera) -> None:
-        if isinstance(camera, Camera):
-            self._camera = camera
-
-    @property
-    def look_at(self) -> datetime:
-        return self._look_at
-
-    @look_at.setter
-    def look_at(self, look_at) -> None:
-        if isinstance(look_at, LookAt):
-            self._look_at = look_at
-
-    @property
-    def link(self):
-        return self._atom_link.href
-
-    @link.setter
-    def link(self, url) -> None:
-        if isinstance(url, str):
-            self._atom_link = atom.Link(href=url)
-        elif isinstance(url, atom.Link):
-            self._atom_link = url
-        elif url is None:
-            self._atom_link = None
-        else:
-            raise TypeError
-
-    @property
-    def author(self) -> None:
-        if self._atom_author:
-            return self._atom_author.name
-        return None
-
-    @author.setter
-    def author(self, name) -> None:
-        if isinstance(name, atom.Author):
-            self._atom_author = name
-        elif isinstance(name, str):
-            if self._atom_author is None:
-                self._atom_author = atom.Author(ns=config.ATOMNS, name=name)
-            else:
-                self._atom_author.name = name
-        elif name is None:
-            self._atom_author = None
-        else:
-            raise TypeError
-
-    def append_style(self, style: Union[Style, StyleMap]) -> None:
-        """Append a style to the feature."""
-        if isinstance(style, _StyleSelector):
-            self._styles.append(style)
-        else:
-            raise TypeError
-
-    def styles(self) -> Iterator[Union[Style, StyleMap]]:
-        """Iterate over the styles of this feature."""
-        for style in self._styles:
-            if isinstance(style, _StyleSelector):
-                yield style
-            else:
-                raise TypeError
-
-    @property
-    def snippet(self) -> Optional[Dict[str, Any]]:
-        if not self._snippet:
-            return None
-        if isinstance(self._snippet, dict):
-            text = self._snippet.get("text")
-            if text:
-                assert isinstance(text, str)
-                max_lines = self._snippet.get("maxLines", None)
-                if max_lines is None:
-                    return {"text": text}
-                elif int(max_lines) > 0:
-                    # if maxLines <=0 ignore it
-                    return {"text": text, "maxLines": max_lines}
-                return None
-            return None
-        elif isinstance(self._snippet, str):
-            return self._snippet
-        else:
-            msg = "Snippet must be dict of {'text':t, 'maxLines':i} or string"
-            raise ValueError(
-                msg,
-            )
-
-    @snippet.setter
-    def snippet(self, snip=None) -> None:
-        self._snippet = {}
-        if isinstance(snip, dict):
-            self._snippet["text"] = snip.get("text")
-            max_lines = snip.get("maxLines")
-            if max_lines is not None:
-                self._snippet["maxLines"] = int(snip["maxLines"])
-        elif isinstance(snip, str):
-            self._snippet["text"] = snip
-        elif snip is None:
-            self._snippet = None
-        else:
-            msg = "Snippet must be dict of {'text':t, 'maxLines':i} or string"
-            raise ValueError(
-                msg,
-            )
-
-    @property
-    def address(self) -> None:
-        if self._address:
-            return self._address
-        return None
-
-    @address.setter
-    def address(self, address) -> None:
-        if isinstance(address, str):
-            self._address = address
-        elif address is None:
-            self._address = None
-        else:
-            raise ValueError
-
-    @property
-    def phone_number(self) -> None:
-        if self._phone_number:
-            return self._phone_number
-        return None
-
-    @phone_number.setter
-    def phone_number(self, phone_number) -> None:
-        if isinstance(phone_number, str):
-            self._phone_number = phone_number
-        elif phone_number is None:
-            self._phone_number = None
-        else:
-            raise ValueError
-
-    def etree_element(
-        self,
-        precision: Optional[int] = None,
-        verbosity: Verbosity = Verbosity.normal,
-    ) -> Element:
-        element = super().etree_element(precision=precision, verbosity=verbosity)
-        if self.name:
-            name = config.etree.SubElement(element, f"{self.ns}name")
-            name.text = self.name
-        if self.description:
-            description = config.etree.SubElement(element, f"{self.ns}description")
-            description.text = self.description
-        if (self.camera is not None) and (self.look_at is not None):
-            msg = "Either Camera or LookAt can be defined, not both"
-            raise ValueError(msg)
-        if self.camera is not None:
-            element.append(self._camera.etree_element())
-        elif self.look_at is not None:
-            element.append(self._look_at.etree_element())
-        if self.visibility is not None:
-            visibility = config.etree.SubElement(element, f"{self.ns}visibility")
-            visibility.text = str(self.visibility)
-        if self.isopen:
-            isopen = config.etree.SubElement(element, f"{self.ns}open")
-            isopen.text = str(self.isopen)
-        if self._style_url is not None:
-            element.append(self._style_url.etree_element())
-        for style in self.styles():
-            element.append(style.etree_element())
-        if self.snippet:
-            snippet = config.etree.SubElement(element, f"{self.ns}Snippet")
-            if isinstance(self.snippet, str):
-                snippet.text = self.snippet
-            else:
-                assert isinstance(self.snippet["text"], str)
-                snippet.text = self.snippet["text"]
-                if self.snippet.get("maxLines"):
-                    snippet.set("maxLines", str(self.snippet["maxLines"]))
-        if (self._timespan is not None) and (self._timestamp is not None):
-            msg = "Either Timestamp or Timespan can be defined, not both"
-            raise ValueError(msg)
-        elif self._timespan is not None:
-            element.append(self._timespan.etree_element())
-        elif self._timestamp is not None:
-            element.append(self._timestamp.etree_element())
-        if self._atom_link is not None:
-            element.append(self._atom_link.etree_element())
-        if self._atom_author is not None:
-            element.append(self._atom_author.etree_element())
-        if self.extended_data is not None:
-            element.append(self.extended_data.etree_element())
-        if self._address is not None:
-            address = config.etree.SubElement(element, f"{self.ns}address")
-            address.text = self._address
-        if self._phone_number is not None:
-            phone_number = config.etree.SubElement(element, f"{self.ns}phoneNumber")
-            phone_number.text = self._phone_number
-        return element
-
-    def from_element(self, element: Element, strict: bool = False) -> None:
-        super().from_element(element)
-        name = element.find(f"{self.ns}name")
-        if name is not None:
-            self.name = name.text
-        description = element.find(f"{self.ns}description")
-        if description is not None:
-            self.description = description.text
-        visibility = element.find(f"{self.ns}visibility")
-        if visibility is not None and visibility.text:
-            self.visibility = 1 if visibility.text in ["1", "true"] else 0
-        isopen = element.find(f"{self.ns}open")
-        if isopen is not None:
-            self.isopen = 1 if isopen.text in ["1", "true"] else 0
-        styles = element.findall(f"{self.ns}Style")
-        for style in styles:
-            s = Style.class_from_element(
-                ns=self.ns,
-                name_spaces=self.name_spaces,
-                element=style,
-                strict=strict,
-            )
-            self.append_style(s)
-        styles = element.findall(f"{self.ns}StyleMap")
-        for style in styles:
-            s = StyleMap.class_from_element(
-                ns=self.ns,
-                name_spaces=self.name_spaces,
-                element=style,
-                strict=strict,
-            )
-            self.append_style(s)
-        style_url = element.find(f"{self.ns}styleUrl")
-        if style_url is not None:
-            self._style_url = StyleUrl.class_from_element(
-                ns=self.ns,
-                name_spaces=self.name_spaces,
-                element=style_url,
-                strict=strict,
-            )
-        snippet = element.find(f"{self.ns}Snippet")
-        if snippet is not None:
-            _snippet = {"text": snippet.text}
-            if snippet.get("maxLines"):
-                _snippet["maxLines"] = int(snippet.get("maxLines"))
-            self.snippet = _snippet
-        timespan = element.find(f"{self.ns}TimeSpan")
-        if timespan is not None:
-            self._timespan = TimeSpan.class_from_element(
-                ns=self.ns,
-                name_spaces=self.name_spaces,
-                element=timespan,
-                strict=strict,
-            )
-        timestamp = element.find(f"{self.ns}TimeStamp")
-        if timestamp is not None:
-            self._timestamp = TimeStamp.class_from_element(
-                ns=self.ns,
-                name_spaces=self.name_spaces,
-                element=timestamp,
-                strict=strict,
-            )
-        atom_link = element.find(f"{atom.NS}link")
-        if atom_link is not None:
-            self._atom_link = atom.Link.class_from_element(
-                ns=atom.NS,
-                name_spaces=self.name_spaces,
-                element=atom_link,
-                strict=strict,
-            )
-        atom_author = element.find(f"{atom.NS}author")
-        if atom_author is not None:
-            self._atom_author = atom.Author.class_from_element(
-                ns=atom.NS,
-                name_spaces=self.name_spaces,
-                element=atom_author,
-                strict=strict,
-            )
-        extended_data = element.find(f"{self.ns}ExtendedData")
-        if extended_data is not None:
-            self.extended_data = ExtendedData.class_from_element(
-                ns=self.ns,
-                element=extended_data,
-                strict=strict,
-            )
-        address = element.find(f"{self.ns}address")
-        if address is not None:
-            self.address = address.text
-        phone_number = element.find(f"{self.ns}phoneNumber")
-        if phone_number is not None:
-            self.phone_number = phone_number.text
-        camera = element.find(f"{self.ns}Camera")
-        if camera is not None:
-            s = Camera(self.ns)
-            s.from_element(camera)
-            self.camera = s
-
-
-class _Container(_Feature):
-    """
-    abstract element; do not create
-    A Container element holds one or more Features and allows the
-    creation of nested hierarchies.
-    subclasses are:
-    Document,
-    Folder.
-    """
-
-    _features = []
-
-    def __init__(
-        self,
-        ns: Optional[str] = None,
-        name_spaces: Optional[Dict[str, str]] = None,
-        id: Optional[str] = None,
-        target_id: Optional[str] = None,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        styles: Optional[List[Style]] = None,
-        style_url: Optional[str] = None,
-        features: None = None,
-    ) -> None:
-        super().__init__(
-            ns=ns,
-            name_spaces=name_spaces,
-            id=id,
-            target_id=target_id,
-            name=name,
-            description=description,
-            styles=styles,
-            style_url=style_url,
-        )
-        self._features = features or []
-
-    def features(self) -> Iterator[_Feature]:
-        """Iterate over features."""
-        for feature in self._features:
-            if isinstance(feature, (Folder, Placemark, Document, _Overlay)):
-                yield feature
-            else:
-                msg = (
-                    "Features must be instances of "
-                    "(Folder, Placemark, Document, Overlay)"
-                )
-                raise TypeError(
-                    msg,
-                )
-
-    def etree_element(
-        self,
-        precision: Optional[int] = None,
-        verbosity: Verbosity = Verbosity.normal,
-    ) -> Element:
-        element = super().etree_element(precision=precision, verbosity=verbosity)
-        for feature in self.features():
-            element.append(feature.etree_element())
-        return element
-
-    def append(self, kmlobj: _Feature) -> None:
-        """Append a feature."""
-        if id(kmlobj) == id(self):
-            msg = "Cannot append self"
-            raise ValueError(msg)
-        if isinstance(kmlobj, (Folder, Placemark, Document, _Overlay)):
-            self._features.append(kmlobj)
-        else:
-            msg = "Features must be instances of (Folder, Placemark, Document, Overlay)"
-            raise TypeError(
-                msg,
-            )
-
-
-class _Overlay(_Feature):
-    """
-    abstract element; do not create.
-
-    Base type for image overlays drawn on the planet surface or on the screen
-
-    A Container element holds one or more Features and allows the creation of
-    nested hierarchies.
-    """
-
-    _color: Optional[str]
-    # Color values expressed in hexadecimal notation, including opacity (alpha)
-    # values. The order of expression is alphaOverlay, blue, green, red
-    # (AABBGGRR). The range of values for any one color is 0 to 255 (00 to ff).
-    # For opacity, 00 is fully transparent and ff is fully opaque.
-
-    _draw_order: Optional[str]
-    # Defines the stacking order for the images in overlapping overlays.
-    # Overlays with higher <drawOrder> values are drawn on top of those with
-    # lower <drawOrder> values.
-
-    _icon: Optional[Icon]
-    # Defines the image associated with the overlay. Contains an <href> html
-    # tag which defines the location of the image to be used as the overlay.
-    # The location can be either on a local file system or on a webserver. If
-    # this element is omitted or contains no <href>, a rectangle is drawn using
-    # the color and size defined by the ground or screen overlay.
-
-    def __init__(
-        self,
-        ns: Optional[str] = None,
-        name_spaces: Optional[Dict[str, str]] = None,
-        id: Optional[str] = None,
-        target_id: Optional[str] = None,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        color: Optional[str] = None,
-        styles: None = None,
-        style_url: Optional[str] = None,
-        draw_order: Optional[str] = None,
-        icon: Optional[Icon] = None,
-    ) -> None:
-        super().__init__(
-            ns=ns,
-            name_spaces=name_spaces,
-            id=id,
-            target_id=target_id,
-            name=name,
-            description=description,
-            styles=styles,
-            style_url=style_url,
-        )
-        self._icon = icon
-        self._color = color
-        self._draw_order = draw_order
-
-    @property
-    def color(self):
-        return self._color
-
-    @color.setter
-    def color(self, color) -> None:
-        if isinstance(color, str):
-            self._color = color
-        elif color is None:
-            self._color = None
-        else:
-            raise ValueError
-
-    @property
-    def draw_order(self) -> Optional[str]:
-        return self._draw_order
-
-    @draw_order.setter
-    def draw_order(self, value) -> None:
-        if isinstance(value, (str, int, float)):
-            self._draw_order = str(value)
-        elif value is None:
-            self._draw_order = None
-        else:
-            raise ValueError
-
-    @property
-    def icon(self) -> Optional[Icon]:
-        return self._icon
-
-    @icon.setter
-    def icon(self, value) -> None:
-        if isinstance(value, Icon):
-            self._icon = value
-        elif value is None:
-            self._icon = None
-        else:
-            raise ValueError
-
-    def etree_element(
-        self,
-        precision: Optional[int] = None,
-        verbosity: Verbosity = Verbosity.normal,
-    ) -> Element:
-        element = super().etree_element(precision=precision, verbosity=verbosity)
-        if self._color:
-            color = config.etree.SubElement(element, f"{self.ns}color")
-            color.text = self._color
-        if self._draw_order:
-            draw_order = config.etree.SubElement(element, f"{self.ns}drawOrder")
-            draw_order.text = self._draw_order
-        if self._icon:
-            element.append(self._icon.etree_element())
-        return element
-
-    def from_element(self, element: Element) -> None:
-        super().from_element(element)
-        color = element.find(f"{self.ns}color")
-        if color is not None:
-            self.color = color.text
-        draw_order = element.find(f"{self.ns}drawOrder")
-        if draw_order is not None:
-            self.draw_order = draw_order.text
-        icon = element.find(f"{self.ns}Icon")
-        if icon is not None:
-            self._icon = Icon.class_from_element(
-                ns=self.ns,
-                name_spaces=self.name_spaces,
-                element=icon,
-                strict=False,
-            )
-
-
-class PhotoOverlay(_Overlay):
-    """
-    The <PhotoOverlay> element allows you to geographically locate a photograph
-    on the Earth and to specify viewing parameters for this PhotoOverlay.
-    The PhotoOverlay can be a simple 2D rectangle, a partial or full cylinder,
-    or a sphere (for spherical panoramas). The overlay is placed at the
-    specified location and oriented toward the viewpoint.
-
-    Because <PhotoOverlay> is derived from <Feature>, it can contain one of
-    the two elements derived from <AbstractView>—either <Camera> or <LookAt>.
-    The Camera (or LookAt) specifies a viewpoint and a viewing direction (also
-    referred to as a view vector). The PhotoOverlay is positioned in relation
-    to the viewpoint. Specifically, the plane of a 2D rectangular image is
-    orthogonal (at right angles to) the view vector. The normal of this
-    plane—that is, its front, which is the part
-    with the photo—is oriented toward the viewpoint.
-
-    The URL for the PhotoOverlay image is specified in the <Icon> tag,
-    which is inherited from <Overlay>. The <Icon> tag must contain an <href>
-    element that specifies the image file to use for the PhotoOverlay.
-    In the case of a very large image, the <href> is a special URL that
-    indexes into a pyramid of images of varying resolutions (see ImagePyramid).
-    """
-
-    __name__ = "PhotoOverlay"
-
-    _rotation = None
-    # Adjusts how the photo is placed inside the field of view. This element is
-    # useful if your photo has been rotated and deviates slightly from a desired
-    # horizontal view.
-
-    # - ViewVolume -
-    # Defines how much of the current scene is visible. Specifying the field of
-    # view is analogous to specifying the lens opening in a physical camera.
-    # A small field of view, like a telephoto lens, focuses on a small part of
-    # the scene. A large field of view, like a wide-angle lens, focuses on a
-    # large part of the scene.
-
-    _left_fow = None
-    # Angle, in degrees, between the camera's viewing direction and the left side
-    # of the view volume.
-
-    _right_fov = None
-    # Angle, in degrees, between the camera's viewing direction and the right side
-    # of the view volume.
-
-    _bottom_fov = None
-    # Angle, in degrees, between the camera's viewing direction and the bottom side
-    # of the view volume.
-
-    _top_fov = None
-    # Angle, in degrees, between the camera's viewing direction and the top side
-    # of the view volume.
-
-    _near = None
-    # Measurement in meters along the viewing direction from the camera viewpoint
-    # to the PhotoOverlay shape.
-
-    _tile_size = "256"
-    # Size of the tiles, in pixels. Tiles must be square, and <tileSize> must
-    # be a power of 2. A tile size of 256 (the default) or 512 is recommended.
-    # The original image is divided into tiles of this size, at varying resolutions.
-
-    _max_width = None
-    # Width in pixels of the original image.
-
-    _max_height = None
-    # Height in pixels of the original image.
-
-    _grid_origin: Optional[GridOrigin]
-    # Specifies where to begin numbering the tiles in each layer of the pyramid.
-    # A value of lowerLeft specifies that row 1, column 1 of each layer is in
-    # the bottom left corner of the grid.
-
-    _point: Optional[Point]
-    # The <Point> element acts as a <Point> inside a <Placemark> element.
-    # It draws an icon to mark the position of the PhotoOverlay.
-    # The icon drawn is specified by the <styleUrl> and <StyleSelector> fields,
-    # just as it is for <Placemark>.
-
-    _shape: Optional[Shape]
-    # The PhotoOverlay is projected onto the <shape>.
-    # The <shape> can be one of the following:
-    #   rectangle (default) -
-    #       for an ordinary photo
-    #   cylinder -
-    #       for panoramas, which can be either partial or full cylinders
-    #   sphere -
-    #       for spherical panoramas
-
-    @property
-    def rotation(self) -> Optional[str]:
-        return self._rotation
-
-    @rotation.setter
-    def rotation(self, value) -> None:
-        if isinstance(value, (str, int, float)):
-            self._rotation = str(value)
-        elif value is None:
-            self._rotation = None
-        else:
-            raise ValueError
-
-    @property
-    def left_fov(self) -> Optional[str]:
-        return self._left_fow
-
-    @left_fov.setter
-    def left_fov(self, value) -> None:
-        if isinstance(value, (str, int, float)):
-            self._left_fow = str(value)
-        elif value is None:
-            self._left_fow = None
-        else:
-            raise ValueError
-
-    @property
-    def right_fov(self) -> Optional[str]:
-        return self._right_fov
-
-    @right_fov.setter
-    def right_fov(self, value) -> None:
-        if isinstance(value, (str, int, float)):
-            self._right_fov = str(value)
-        elif value is None:
-            self._right_fov = None
-        else:
-            raise ValueError
-
-    @property
-    def bottom_fov(self) -> Optional[str]:
-        return self._bottom_fov
-
-    @bottom_fov.setter
-    def bottom_fov(self, value) -> None:
-        if isinstance(value, (str, int, float)):
-            self._bottom_fov = str(value)
-        elif value is None:
-            self._bottom_fov = None
-        else:
-            raise ValueError
-
-    @property
-    def top_fov(self) -> Optional[str]:
-        return self._top_fov
-
-    @top_fov.setter
-    def top_fov(self, value) -> None:
-        if isinstance(value, (str, int, float)):
-            self._top_fov = str(value)
-        elif value is None:
-            self._top_fov = None
-        else:
-            raise ValueError
-
-    @property
-    def near(self) -> Optional[str]:
-        return self._near
-
-    @near.setter
-    def near(self, value) -> None:
-        if isinstance(value, (str, int, float)):
-            self._near = str(value)
-        elif value is None:
-            self._near = None
-        else:
-            raise ValueError
-
-    @property
-    def tile_size(self) -> Optional[str]:
-        return self._tile_size
-
-    @tile_size.setter
-    def tile_size(self, value) -> None:
-        if isinstance(value, (str, int, float)):
-            self._tile_size = str(value)
-        elif value is None:
-            self._tile_size = None
-        else:
-            raise ValueError
-
-    @property
-    def max_width(self) -> Optional[str]:
-        return self._max_width
-
-    @max_width.setter
-    def max_width(self, value) -> None:
-        if isinstance(value, (str, int, float)):
-            self._max_width = str(value)
-        elif value is None:
-            self._max_width = None
-        else:
-            raise ValueError
-
-    @property
-    def max_height(self) -> Optional[str]:
-        return self._max_height
-
-    @max_height.setter
-    def max_height(self, value) -> None:
-        if isinstance(value, (str, int, float)):
-            self._max_height = str(value)
-        elif value is None:
-            self._max_height = None
-        else:
-            raise ValueError
-
-    @property
-    def grid_origin(self) -> Optional[GridOrigin]:
-        return self._grid_origin
-
-    @grid_origin.setter
-    def grid_origin(self, value: Optional[GridOrigin]) -> None:
-        self._grid_origin = value
-
-    @property
-    def point(self) -> str:
-        return self._point
-
-    @point.setter
-    def point(self, value) -> None:
-        if isinstance(value, (str, tuple)):
-            self._point = str(value)
-        else:
-            raise ValueError
-
-    @property
-    def shape(self) -> Optional[Shape]:
-        return self._shape
-
-    @shape.setter
-    def shape(self, value: Optional[Shape]) -> None:
-        self._shape = value
-
-    def view_volume(self, left_fov, right_fov, bottom_fov, top_fov, near) -> None:
-        self.left_fov = left_fov
-        self.right_fov = right_fov
-        self.bottom_fov = bottom_fov
-        self.top_fov = top_fov
-        self.near = near
-
-    def image_pyramid(self, tile_size, max_width, max_height, grid_origin) -> None:
-        self.tile_size = tile_size
-        self.max_width = max_width
-        self.max_height = max_height
-        self.grid_origin = grid_origin
-
-    def etree_element(
-        self,
-        precision: Optional[int] = None,
-        verbosity: Verbosity = Verbosity.normal,
-    ) -> Element:
-        element = super().etree_element(precision=precision, verbosity=verbosity)
-        if self._rotation:
-            rotation = config.etree.SubElement(element, f"{self.ns}rotation")
-            rotation.text = self._rotation
-        if all(
-            [
-                self._left_fow,
-                self._right_fov,
-                self._bottom_fov,
-                self._top_fov,
-                self._near,
-            ],
-        ):
-            view_volume = config.etree.SubElement(element, f"{self.ns}ViewVolume")
-            left_fov = config.etree.SubElement(view_volume, f"{self.ns}leftFov")
-            left_fov.text = self._left_fow
-            right_fov = config.etree.SubElement(view_volume, f"{self.ns}rightFov")
-            right_fov.text = self._right_fov
-            bottom_fov = config.etree.SubElement(view_volume, f"{self.ns}bottomFov")
-            bottom_fov.text = self._bottom_fov
-            top_fov = config.etree.SubElement(view_volume, f"{self.ns}topFov")
-            top_fov.text = self._top_fov
-            near = config.etree.SubElement(view_volume, f"{self.ns}near")
-            near.text = self._near
-        if all([self._tile_size, self._max_width, self._max_height, self._grid_origin]):
-            image_pyramid = config.etree.SubElement(element, f"{self.ns}ImagePyramid")
-            tile_size = config.etree.SubElement(image_pyramid, f"{self.ns}tileSize")
-            tile_size.text = self._tile_size
-            max_width = config.etree.SubElement(image_pyramid, f"{self.ns}maxWidth")
-            max_width.text = self._max_width
-            max_height = config.etree.SubElement(image_pyramid, f"{self.ns}maxHeight")
-            max_height.text = self._max_height
-            grid_origin = config.etree.SubElement(image_pyramid, f"{self.ns}gridOrigin")
-            grid_origin.text = self._grid_origin
-        return element
-
-    def from_element(self, element) -> None:
-        super().from_element(element)
-        rotation = element.find(f"{self.ns}rotation")
-        if rotation is not None:
-            self.rotation = rotation.text
-        view_volume = element.find(f"{self.ns}ViewVolume")
-        if view_volume is not None:
-            left_fov = view_volume.find(f"{self.ns}leftFov")
-            if left_fov is not None:
-                self.left_fov = left_fov.text
-            right_fov = view_volume.find(f"{self.ns}rightFov")
-            if right_fov is not None:
-                self.right_fov = right_fov.text
-            bottom_fov = view_volume.find(f"{self.ns}bottomFov")
-            if bottom_fov is not None:
-                self.bottom_fov = bottom_fov.text
-            top_fov = view_volume.find(f"{self.ns}topFov")
-            if top_fov is not None:
-                self.top_fov = top_fov.text
-            near = view_volume.find(f"{self.ns}near")
-            if near is not None:
-                self.near = near.text
-        image_pyramid = element.find(f"{self.ns}ImagePyramid")
-        if image_pyramid is not None:
-            tile_size = image_pyramid.find(f"{self.ns}tileSize")
-            if tile_size is not None:
-                self.tile_size = tile_size.text
-            max_width = image_pyramid.find(f"{self.ns}maxWidth")
-            if max_width is not None:
-                self.max_width = max_width.text
-            max_height = image_pyramid.find(f"{self.ns}maxHeight")
-            if max_height is not None:
-                self.max_height = max_height.text
-            grid_origin = image_pyramid.find(f"{self.ns}gridOrigin")
-            if grid_origin is not None:
-                self.grid_origin = grid_origin.text
-        point = element.find(f"{self.ns}Point")
-        if point is not None:
-            self.point = point.text
-        shape = element.find(f"{self.ns}shape")
-        if shape is not None:
-            self.shape = shape.text
-
-
-class GroundOverlay(_Overlay):
-    """
-    This element draws an image overlay draped onto the terrain. The <href>
-    child of <Icon> specifies the image to be used as the overlay. This file
-    can be either on a local file system or on a web server. If this element
-    is omitted or contains no <href>, a rectangle is drawn using the color and
-    LatLonBox bounds defined by the ground overlay.
-    """
-
-    __name__ = "GroundOverlay"
-
-    _altitude = None
-    # Specifies the distance above the earth's surface, in meters, and is
-    # interpreted according to the altitude mode.
-
-    _altitude_mode = "clampToGround"
-    # Specifies how the <altitude> is interpreted. Possible values are:
-    #   clampToGround -
-    #       (default) Indicates to ignore the altitude specification and drape
-    #       the overlay over the terrain.
-    #   absolute -
-    #       Sets the altitude of the overlay relative to sea level, regardless
-    #       of the actual elevation of the terrain beneath the element. For
-    #       example, if you set the altitude of an overlay to 10 meters with an
-    #       absolute altitude mode, the overlay will appear to be at ground
-    #       level if the terrain beneath is also 10 meters above sea level. If
-    #       the terrain is 3 meters above sea level, the overlay will appear
-    #       elevated above the terrain by 7 meters.
-
-    # - LatLonBox -
-    # TODO: Convert this to it's own class?
-    # Specifies where the top, bottom, right, and left sides of a bounding box
-    # for the ground overlay are aligned. Also, optionally the rotation of the
-    # overlay.
-
-    _north = None
-    # Specifies the latitude of the north edge of the bounding box, in decimal
-    # degrees from 0 to ±90.
-
-    _south = None
-    # Specifies the latitude of the south edge of the bounding box, in decimal
-    # degrees from 0 to ±90.
-
-    _east = None
-    # Specifies the longitude of the east edge of the bounding box, in decimal
-    # degrees from 0 to ±180. (For overlays that overlap the meridian of 180°
-    # longitude, values can extend beyond that range.)
-
-    _west = None
-    # Specifies the longitude of the west edge of the bounding box, in decimal
-    # degrees from 0 to ±180. (For overlays that overlap the meridian of 180°
-    # longitude, values can extend beyond that range.)
-
-    _rotation = None
-    # Specifies a rotation of the overlay about its center, in degrees. Values
-    # can be ±180. The default is 0 (north). Rotations are specified in a
-    # counterclockwise direction.
-
-    # TODO: <gx:LatLonQuad>
-    # Used for nonrectangular quadrilateral ground overlays.
-    _lat_lon_quad = None
-
-    @property
-    def altitude(self) -> Optional[str]:
-        return self._altitude
-
-    @altitude.setter
-    def altitude(self, value) -> None:
-        if isinstance(value, (str, int, float)):
-            self._altitude = str(value)
-        elif value is None:
-            self._altitude = None
-        else:
-            raise ValueError
-
-    @property
-    def altitude_mode(self) -> str:
-        return self._altitude_mode
-
-    @altitude_mode.setter
-    def altitude_mode(self, mode) -> None:
-        if mode in ("clampToGround", "absolute"):
-            self._altitude_mode = str(mode)
-        else:
-            self._altitude_mode = "clampToGround"
-
-    @property
-    def north(self) -> Optional[str]:
-        return self._north
-
-    @north.setter
-    def north(self, value) -> None:
-        if isinstance(value, (str, int, float)):
-            self._north = str(value)
-        elif value is None:
-            self._north = None
-        else:
-            raise ValueError
-
-    @property
-    def south(self) -> Optional[str]:
-        return self._south
-
-    @south.setter
-    def south(self, value) -> None:
-        if isinstance(value, (str, int, float)):
-            self._south = str(value)
-        elif value is None:
-            self._south = None
-        else:
-            raise ValueError
-
-    @property
-    def east(self) -> Optional[str]:
-        return self._east
-
-    @east.setter
-    def east(self, value) -> None:
-        if isinstance(value, (str, int, float)):
-            self._east = str(value)
-        elif value is None:
-            self._east = None
-        else:
-            raise ValueError
-
-    @property
-    def west(self) -> Optional[str]:
-        return self._west
-
-    @west.setter
-    def west(self, value) -> None:
-        if isinstance(value, (str, int, float)):
-            self._west = str(value)
-        elif value is None:
-            self._west = None
-        else:
-            raise ValueError
-
-    @property
-    def rotation(self) -> Optional[str]:
-        return self._rotation
-
-    @rotation.setter
-    def rotation(self, value) -> None:
-        if isinstance(value, (str, int, float)):
-            self._rotation = str(value)
-        elif value is None:
-            self._rotation = None
-        else:
-            raise ValueError
-
-    def lat_lon_box(
-        self,
-        north: int,
-        south: int,
-        east: int,
-        west: int,
-        rotation: int = 0,
-    ) -> None:
-        if -90 <= float(north) <= 90:
-            self.north = north
-        else:
-            raise ValueError
-        if -90 <= float(south) <= 90:
-            self.south = south
-        else:
-            raise ValueError
-        if -180 <= float(east) <= 180:
-            self.east = east
-        else:
-            raise ValueError
-        if -180 <= float(west) <= 180:
-            self.west = west
-        else:
-            raise ValueError
-        if -180 <= float(rotation) <= 180:
-            self.rotation = rotation
-        else:
-            raise ValueError
-
-    def etree_element(
-        self,
-        precision: Optional[int] = None,
-        verbosity: Verbosity = Verbosity.normal,
-    ) -> Element:
-        element = super().etree_element(precision=precision, verbosity=verbosity)
-        if self._altitude:
-            altitude = config.etree.SubElement(element, f"{self.ns}altitude")
-            altitude.text = self._altitude
-            if self._altitude_mode:
-                altitude_mode = config.etree.SubElement(
-                    element,
-                    f"{self.ns}altitudeMode",
-                )
-                altitude_mode.text = self._altitude_mode
-        if all([self._north, self._south, self._east, self._west]):
-            lat_lon_box = config.etree.SubElement(element, f"{self.ns}LatLonBox")
-            north = config.etree.SubElement(lat_lon_box, f"{self.ns}north")
-            north.text = self._north
-            south = config.etree.SubElement(lat_lon_box, f"{self.ns}south")
-            south.text = self._south
-            east = config.etree.SubElement(lat_lon_box, f"{self.ns}east")
-            east.text = self._east
-            west = config.etree.SubElement(lat_lon_box, f"{self.ns}west")
-            west.text = self._west
-            if self._rotation:
-                rotation = config.etree.SubElement(lat_lon_box, f"{self.ns}rotation")
-                rotation.text = self._rotation
-        return element
-
-    def from_element(self, element: Element) -> None:
-        super().from_element(element)
-        altitude = element.find(f"{self.ns}altitude")
-        if altitude is not None:
-            self.altitude = altitude.text
-        altitude_mode = element.find(f"{self.ns}altitudeMode")
-        if altitude_mode is not None:
-            self.altitude_mode = altitude_mode.text
-        lat_lon_box = element.find(f"{self.ns}LatLonBox")
-        if lat_lon_box is not None:
-            north = lat_lon_box.find(f"{self.ns}north")
-            if north is not None:
-                self.north = north.text
-            south = lat_lon_box.find(f"{self.ns}south")
-            if south is not None:
-                self.south = south.text
-            east = lat_lon_box.find(f"{self.ns}east")
-            if east is not None:
-                self.east = east.text
-            west = lat_lon_box.find(f"{self.ns}west")
-            if west is not None:
-                self.west = west.text
-            rotation = lat_lon_box.find(f"{self.ns}rotation")
-            if rotation is not None:
-                self.rotation = rotation.text
-
-
-class Document(_Container):
-    """
-    A Document is a container for features and styles. This element is
-    required if your KML file uses shared styles or schemata for typed
-    extended data.
-    """
-
-    __name__ = "Document"
-    _schemata = None
-
-    def schemata(self) -> Iterator["Schema"]:
-        if self._schemata:
-            yield from self._schemata
-
-    def append_schema(self, schema: "Schema") -> None:
-        if self._schemata is None:
-            self._schemata = []
-        if isinstance(schema, Schema):
-            self._schemata.append(schema)
-        else:
-            s = Schema(schema)
-            self._schemata.append(s)
-
-    def from_element(self, element: Element, strict: bool = False) -> None:
-        super().from_element(element)
-        documents = element.findall(f"{self.ns}Document")
-        for document in documents:
-            feature = Document(self.ns)
-            feature.from_element(document)
-            self.append(feature)
-        folders = element.findall(f"{self.ns}Folder")
-        for folder in folders:
-            feature = Folder(self.ns)
-            feature.from_element(folder)
-            self.append(feature)
-        placemarks = element.findall(f"{self.ns}Placemark")
-        for placemark in placemarks:
-            feature = Placemark(self.ns)
-            feature.from_element(placemark)
-            self.append(feature)
-        schemata = element.findall(f"{self.ns}Schema")
-        for schema in schemata:
-            s = Schema.class_from_element(ns=self.ns, element=schema, strict=strict)
-            self.append_schema(s)
-
-    def etree_element(
-        self,
-        precision: Optional[int] = None,
-        verbosity: Verbosity = Verbosity.normal,
-    ) -> Element:
-        element = super().etree_element(precision=precision, verbosity=verbosity)
-        if self._schemata is not None:
-            for schema in self._schemata:
-                element.append(schema.etree_element())
-        return element
-
-    def get_style_by_url(self, style_url: str) -> Optional[Union[Style, StyleMap]]:
-        id = urlparse.urlparse(style_url).fragment
-        for style in self.styles():
-            if style.id == id:
-                return style
-        return None
-
-
-class Folder(_Container):
-    """
-    A Folder is used to arrange other Features hierarchically
-    (Folders, Placemarks, #NetworkLinks, or #Overlays).
-    """
-
-    __name__ = "Folder"
-
-    def from_element(self, element: Element) -> None:
-        super().from_element(element)
-        folders = element.findall(f"{self.ns}Folder")
-        for folder in folders:
-            feature = Folder(self.ns)
-            feature.from_element(folder)
-            self.append(feature)
-        placemarks = element.findall(f"{self.ns}Placemark")
-        for placemark in placemarks:
-            feature = Placemark(self.ns)
-            feature.from_element(placemark)
-            self.append(feature)
-        documents = element.findall(f"{self.ns}Document")
-        for document in documents:
-            feature = Document(self.ns)
-            feature.from_element(document)
-            self.append(feature)
-
-
-class Placemark(_Feature):
-    """
-    A Placemark is a Feature with associated Geometry.
-    In Google Earth, a Placemark appears as a list item in the Places
-    panel. A Placemark with a Point has an icon associated with it that
-    marks a point on the Earth in the 3D viewer.
-    """
-
-    __name__ = "Placemark"
-    _geometry = None
-
-    def __init__(
-        self,
-        ns: Optional[str] = None,
-        name_spaces: Optional[Dict[str, str]] = None,
-        id: Optional[str] = None,
-        target_id: Optional[str] = None,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        styles: Optional[List[Style]] = None,
-        style_url: Optional[str] = None,
-        extended_data: None = None,
-        geometry: Optional[KmlGeometry] = None,
-    ) -> None:
-        super().__init__(
-            ns=ns,
-            name_spaces=name_spaces,
-            id=id,
-            target_id=target_id,
-            name=name,
-            description=description,
-            styles=styles,
-            style_url=style_url,
-            extended_data=extended_data,
-        )
-        self._geometry = geometry
-
-    @property
-    def geometry(self) -> Optional[AnyGeometryType]:
-        if self._geometry is not None:
-            return self._geometry.geometry
-        return None
-
-    def from_element(self, element: Element, strict=False) -> None:
-        super().from_element(element)
-        point = element.find(f"{self.ns}Point")
-        if point is not None:
-            self._geometry = Point.class_from_element(
-                ns=self.ns,
-                element=point,
-                strict=strict,
-            )
-            return
-        line = element.find(f"{self.ns}LineString")
-        if line is not None:
-            self._geometry = LineString.class_from_element(
-                ns=self.ns,
-                element=line,
-                strict=strict,
-            )
-            return
-        polygon = element.find(f"{self.ns}Polygon")
-        if polygon is not None:
-            self._geometry = Polygon.class_from_element(
-                ns=self.ns,
-                element=polygon,
-                strict=strict,
-            )
-            return
-        linearring = element.find(f"{self.ns}LinearRing")
-        if linearring is not None:
-            self._geometry = LinearRing.class_from_element(
-                ns=self.ns,
-                element=linearring,
-                strict=strict,
-            )
-            return
-        multigeometry = element.find(f"{self.ns}MultiGeometry")
-        if multigeometry is not None:
-            self._geometry = MultiGeometry.class_from_element(
-                ns=self.ns,
-                element=multigeometry,
-                strict=strict,
-            )
-            return
-        track = element.find(f"{self.ns}Track")
-        if track is not None:
-            self._geometry = gx.Track.class_from_element(
-                ns=config.GXNS,
-                element=track,
-                strict=strict,
-            )
-            return
-        multitrack = element.find(f"{self.ns}MultiTrack")
-        if multitrack is not None:
-            self._geometry = gx.MultiTrack.class_from_element(
-                ns=config.GXNS,
-                element=multitrack,
-                strict=strict,
-            )
-            return
-        logger.warning("No geometries found")
-        logger.debug("Problem with element: %", config.etree.tostring(element))
-
-    def etree_element(
-        self,
-        precision: Optional[int] = None,
-        verbosity: Verbosity = Verbosity.normal,
-    ) -> Element:
-        element = super().etree_element(precision=precision, verbosity=verbosity)
-        if self._geometry is not None:
-            element.append(self._geometry.etree_element())
-        else:
-            logger.error("Object does not have a geometry")
-        return element
-
 
 class KML:
     """represents a KML File."""
diff --git a/fastkml/overlays.py b/fastkml/overlays.py
new file mode 100644
index 00000000..49946c75
--- /dev/null
+++ b/fastkml/overlays.py
@@ -0,0 +1,732 @@
+"""
+Overlays.
+"""
+
+import logging
+from typing import Dict
+from typing import Optional
+from typing import Union
+
+from fastkml import config
+from fastkml import gx
+from fastkml.enums import GridOrigin
+from fastkml.enums import Shape
+from fastkml.enums import Verbosity
+from fastkml.features import _Feature
+from fastkml.geometry import LinearRing
+from fastkml.geometry import LineString
+from fastkml.geometry import MultiGeometry
+from fastkml.geometry import Point
+from fastkml.geometry import Polygon
+from fastkml.links import Icon
+from fastkml.types import Element
+
+logger = logging.getLogger(__name__)
+
+KmlGeometry = Union[
+    Point,
+    LineString,
+    LinearRing,
+    Polygon,
+    MultiGeometry,
+    gx.MultiTrack,
+    gx.Track,
+]
+
+
+class _Overlay(_Feature):
+    """
+    abstract element; do not create.
+
+    Base type for image overlays drawn on the planet surface or on the screen
+
+    A Container element holds one or more Features and allows the creation of
+    nested hierarchies.
+    """
+
+    _color: Optional[str]
+    # Color values expressed in hexadecimal notation, including opacity (alpha)
+    # values. The order of expression is alphaOverlay, blue, green, red
+    # (AABBGGRR). The range of values for any one color is 0 to 255 (00 to ff).
+    # For opacity, 00 is fully transparent and ff is fully opaque.
+
+    _draw_order: Optional[str]
+    # Defines the stacking order for the images in overlapping overlays.
+    # Overlays with higher <drawOrder> values are drawn on top of those with
+    # lower <drawOrder> values.
+
+    _icon: Optional[Icon]
+    # Defines the image associated with the overlay. Contains an <href> html
+    # tag which defines the location of the image to be used as the overlay.
+    # The location can be either on a local file system or on a webserver. If
+    # this element is omitted or contains no <href>, a rectangle is drawn using
+    # the color and size defined by the ground or screen overlay.
+
+    def __init__(
+        self,
+        ns: Optional[str] = None,
+        name_spaces: Optional[Dict[str, str]] = None,
+        id: Optional[str] = None,
+        target_id: Optional[str] = None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        color: Optional[str] = None,
+        styles: None = None,
+        style_url: Optional[str] = None,
+        draw_order: Optional[str] = None,
+        icon: Optional[Icon] = None,
+    ) -> None:
+        super().__init__(
+            ns=ns,
+            name_spaces=name_spaces,
+            id=id,
+            target_id=target_id,
+            name=name,
+            description=description,
+            styles=styles,
+            style_url=style_url,
+        )
+        self._icon = icon
+        self._color = color
+        self._draw_order = draw_order
+
+    @property
+    def color(self):
+        return self._color
+
+    @color.setter
+    def color(self, color) -> None:
+        if isinstance(color, str):
+            self._color = color
+        elif color is None:
+            self._color = None
+        else:
+            raise ValueError
+
+    @property
+    def draw_order(self) -> Optional[str]:
+        return self._draw_order
+
+    @draw_order.setter
+    def draw_order(self, value) -> None:
+        if isinstance(value, (str, int, float)):
+            self._draw_order = str(value)
+        elif value is None:
+            self._draw_order = None
+        else:
+            raise ValueError
+
+    @property
+    def icon(self) -> Optional[Icon]:
+        return self._icon
+
+    @icon.setter
+    def icon(self, value) -> None:
+        if isinstance(value, Icon):
+            self._icon = value
+        elif value is None:
+            self._icon = None
+        else:
+            raise ValueError
+
+    def etree_element(
+        self,
+        precision: Optional[int] = None,
+        verbosity: Verbosity = Verbosity.normal,
+    ) -> Element:
+        element = super().etree_element(precision=precision, verbosity=verbosity)
+        if self._color:
+            color = config.etree.SubElement(element, f"{self.ns}color")
+            color.text = self._color
+        if self._draw_order:
+            draw_order = config.etree.SubElement(element, f"{self.ns}drawOrder")
+            draw_order.text = self._draw_order
+        if self._icon:
+            element.append(self._icon.etree_element())
+        return element
+
+    def from_element(self, element: Element) -> None:
+        super().from_element(element)
+        color = element.find(f"{self.ns}color")
+        if color is not None:
+            self.color = color.text
+        draw_order = element.find(f"{self.ns}drawOrder")
+        if draw_order is not None:
+            self.draw_order = draw_order.text
+        icon = element.find(f"{self.ns}Icon")
+        if icon is not None:
+            self._icon = Icon.class_from_element(
+                ns=self.ns,
+                name_spaces=self.name_spaces,
+                element=icon,
+                strict=False,
+            )
+
+
+class PhotoOverlay(_Overlay):
+    """
+    The <PhotoOverlay> element allows you to geographically locate a photograph
+    on the Earth and to specify viewing parameters for this PhotoOverlay.
+    The PhotoOverlay can be a simple 2D rectangle, a partial or full cylinder,
+    or a sphere (for spherical panoramas). The overlay is placed at the
+    specified location and oriented toward the viewpoint.
+
+    Because <PhotoOverlay> is derived from <Feature>, it can contain one of
+    the two elements derived from <AbstractView>—either <Camera> or <LookAt>.
+    The Camera (or LookAt) specifies a viewpoint and a viewing direction (also
+    referred to as a view vector). The PhotoOverlay is positioned in relation
+    to the viewpoint. Specifically, the plane of a 2D rectangular image is
+    orthogonal (at right angles to) the view vector. The normal of this
+    plane—that is, its front, which is the part
+    with the photo—is oriented toward the viewpoint.
+
+    The URL for the PhotoOverlay image is specified in the <Icon> tag,
+    which is inherited from <Overlay>. The <Icon> tag must contain an <href>
+    element that specifies the image file to use for the PhotoOverlay.
+    In the case of a very large image, the <href> is a special URL that
+    indexes into a pyramid of images of varying resolutions (see ImagePyramid).
+    """
+
+    __name__ = "PhotoOverlay"
+
+    _rotation = None
+    # Adjusts how the photo is placed inside the field of view. This element is
+    # useful if your photo has been rotated and deviates slightly from a desired
+    # horizontal view.
+
+    # - ViewVolume -
+    # Defines how much of the current scene is visible. Specifying the field of
+    # view is analogous to specifying the lens opening in a physical camera.
+    # A small field of view, like a telephoto lens, focuses on a small part of
+    # the scene. A large field of view, like a wide-angle lens, focuses on a
+    # large part of the scene.
+
+    _left_fow = None
+    # Angle, in degrees, between the camera's viewing direction and the left side
+    # of the view volume.
+
+    _right_fov = None
+    # Angle, in degrees, between the camera's viewing direction and the right side
+    # of the view volume.
+
+    _bottom_fov = None
+    # Angle, in degrees, between the camera's viewing direction and the bottom side
+    # of the view volume.
+
+    _top_fov = None
+    # Angle, in degrees, between the camera's viewing direction and the top side
+    # of the view volume.
+
+    _near = None
+    # Measurement in meters along the viewing direction from the camera viewpoint
+    # to the PhotoOverlay shape.
+
+    _tile_size = "256"
+    # Size of the tiles, in pixels. Tiles must be square, and <tileSize> must
+    # be a power of 2. A tile size of 256 (the default) or 512 is recommended.
+    # The original image is divided into tiles of this size, at varying resolutions.
+
+    _max_width = None
+    # Width in pixels of the original image.
+
+    _max_height = None
+    # Height in pixels of the original image.
+
+    _grid_origin: Optional[GridOrigin]
+    # Specifies where to begin numbering the tiles in each layer of the pyramid.
+    # A value of lowerLeft specifies that row 1, column 1 of each layer is in
+    # the bottom left corner of the grid.
+
+    _point: Optional[Point]
+    # The <Point> element acts as a <Point> inside a <Placemark> element.
+    # It draws an icon to mark the position of the PhotoOverlay.
+    # The icon drawn is specified by the <styleUrl> and <StyleSelector> fields,
+    # just as it is for <Placemark>.
+
+    _shape: Optional[Shape]
+    # The PhotoOverlay is projected onto the <shape>.
+    # The <shape> can be one of the following:
+    #   rectangle (default) -
+    #       for an ordinary photo
+    #   cylinder -
+    #       for panoramas, which can be either partial or full cylinders
+    #   sphere -
+    #       for spherical panoramas
+
+    @property
+    def rotation(self) -> Optional[str]:
+        return self._rotation
+
+    @rotation.setter
+    def rotation(self, value) -> None:
+        if isinstance(value, (str, int, float)):
+            self._rotation = str(value)
+        elif value is None:
+            self._rotation = None
+        else:
+            raise ValueError
+
+    @property
+    def left_fov(self) -> Optional[str]:
+        return self._left_fow
+
+    @left_fov.setter
+    def left_fov(self, value) -> None:
+        if isinstance(value, (str, int, float)):
+            self._left_fow = str(value)
+        elif value is None:
+            self._left_fow = None
+        else:
+            raise ValueError
+
+    @property
+    def right_fov(self) -> Optional[str]:
+        return self._right_fov
+
+    @right_fov.setter
+    def right_fov(self, value) -> None:
+        if isinstance(value, (str, int, float)):
+            self._right_fov = str(value)
+        elif value is None:
+            self._right_fov = None
+        else:
+            raise ValueError
+
+    @property
+    def bottom_fov(self) -> Optional[str]:
+        return self._bottom_fov
+
+    @bottom_fov.setter
+    def bottom_fov(self, value) -> None:
+        if isinstance(value, (str, int, float)):
+            self._bottom_fov = str(value)
+        elif value is None:
+            self._bottom_fov = None
+        else:
+            raise ValueError
+
+    @property
+    def top_fov(self) -> Optional[str]:
+        return self._top_fov
+
+    @top_fov.setter
+    def top_fov(self, value) -> None:
+        if isinstance(value, (str, int, float)):
+            self._top_fov = str(value)
+        elif value is None:
+            self._top_fov = None
+        else:
+            raise ValueError
+
+    @property
+    def near(self) -> Optional[str]:
+        return self._near
+
+    @near.setter
+    def near(self, value) -> None:
+        if isinstance(value, (str, int, float)):
+            self._near = str(value)
+        elif value is None:
+            self._near = None
+        else:
+            raise ValueError
+
+    @property
+    def tile_size(self) -> Optional[str]:
+        return self._tile_size
+
+    @tile_size.setter
+    def tile_size(self, value) -> None:
+        if isinstance(value, (str, int, float)):
+            self._tile_size = str(value)
+        elif value is None:
+            self._tile_size = None
+        else:
+            raise ValueError
+
+    @property
+    def max_width(self) -> Optional[str]:
+        return self._max_width
+
+    @max_width.setter
+    def max_width(self, value) -> None:
+        if isinstance(value, (str, int, float)):
+            self._max_width = str(value)
+        elif value is None:
+            self._max_width = None
+        else:
+            raise ValueError
+
+    @property
+    def max_height(self) -> Optional[str]:
+        return self._max_height
+
+    @max_height.setter
+    def max_height(self, value) -> None:
+        if isinstance(value, (str, int, float)):
+            self._max_height = str(value)
+        elif value is None:
+            self._max_height = None
+        else:
+            raise ValueError
+
+    @property
+    def grid_origin(self) -> Optional[GridOrigin]:
+        return self._grid_origin
+
+    @grid_origin.setter
+    def grid_origin(self, value: Optional[GridOrigin]) -> None:
+        self._grid_origin = value
+
+    @property
+    def point(self) -> str:
+        return self._point
+
+    @point.setter
+    def point(self, value) -> None:
+        if isinstance(value, (str, tuple)):
+            self._point = str(value)
+        else:
+            raise ValueError
+
+    @property
+    def shape(self) -> Optional[Shape]:
+        return self._shape
+
+    @shape.setter
+    def shape(self, value: Optional[Shape]) -> None:
+        self._shape = value
+
+    def view_volume(self, left_fov, right_fov, bottom_fov, top_fov, near) -> None:
+        self.left_fov = left_fov
+        self.right_fov = right_fov
+        self.bottom_fov = bottom_fov
+        self.top_fov = top_fov
+        self.near = near
+
+    def image_pyramid(self, tile_size, max_width, max_height, grid_origin) -> None:
+        self.tile_size = tile_size
+        self.max_width = max_width
+        self.max_height = max_height
+        self.grid_origin = grid_origin
+
+    def etree_element(
+        self,
+        precision: Optional[int] = None,
+        verbosity: Verbosity = Verbosity.normal,
+    ) -> Element:
+        element = super().etree_element(precision=precision, verbosity=verbosity)
+        if self._rotation:
+            rotation = config.etree.SubElement(element, f"{self.ns}rotation")
+            rotation.text = self._rotation
+        if all(
+            [
+                self._left_fow,
+                self._right_fov,
+                self._bottom_fov,
+                self._top_fov,
+                self._near,
+            ],
+        ):
+            view_volume = config.etree.SubElement(element, f"{self.ns}ViewVolume")
+            left_fov = config.etree.SubElement(view_volume, f"{self.ns}leftFov")
+            left_fov.text = self._left_fow
+            right_fov = config.etree.SubElement(view_volume, f"{self.ns}rightFov")
+            right_fov.text = self._right_fov
+            bottom_fov = config.etree.SubElement(view_volume, f"{self.ns}bottomFov")
+            bottom_fov.text = self._bottom_fov
+            top_fov = config.etree.SubElement(view_volume, f"{self.ns}topFov")
+            top_fov.text = self._top_fov
+            near = config.etree.SubElement(view_volume, f"{self.ns}near")
+            near.text = self._near
+        if all([self._tile_size, self._max_width, self._max_height, self._grid_origin]):
+            image_pyramid = config.etree.SubElement(element, f"{self.ns}ImagePyramid")
+            tile_size = config.etree.SubElement(image_pyramid, f"{self.ns}tileSize")
+            tile_size.text = self._tile_size
+            max_width = config.etree.SubElement(image_pyramid, f"{self.ns}maxWidth")
+            max_width.text = self._max_width
+            max_height = config.etree.SubElement(image_pyramid, f"{self.ns}maxHeight")
+            max_height.text = self._max_height
+            grid_origin = config.etree.SubElement(image_pyramid, f"{self.ns}gridOrigin")
+            grid_origin.text = self._grid_origin
+        return element
+
+    def from_element(self, element) -> None:
+        super().from_element(element)
+        rotation = element.find(f"{self.ns}rotation")
+        if rotation is not None:
+            self.rotation = rotation.text
+        view_volume = element.find(f"{self.ns}ViewVolume")
+        if view_volume is not None:
+            left_fov = view_volume.find(f"{self.ns}leftFov")
+            if left_fov is not None:
+                self.left_fov = left_fov.text
+            right_fov = view_volume.find(f"{self.ns}rightFov")
+            if right_fov is not None:
+                self.right_fov = right_fov.text
+            bottom_fov = view_volume.find(f"{self.ns}bottomFov")
+            if bottom_fov is not None:
+                self.bottom_fov = bottom_fov.text
+            top_fov = view_volume.find(f"{self.ns}topFov")
+            if top_fov is not None:
+                self.top_fov = top_fov.text
+            near = view_volume.find(f"{self.ns}near")
+            if near is not None:
+                self.near = near.text
+        image_pyramid = element.find(f"{self.ns}ImagePyramid")
+        if image_pyramid is not None:
+            tile_size = image_pyramid.find(f"{self.ns}tileSize")
+            if tile_size is not None:
+                self.tile_size = tile_size.text
+            max_width = image_pyramid.find(f"{self.ns}maxWidth")
+            if max_width is not None:
+                self.max_width = max_width.text
+            max_height = image_pyramid.find(f"{self.ns}maxHeight")
+            if max_height is not None:
+                self.max_height = max_height.text
+            grid_origin = image_pyramid.find(f"{self.ns}gridOrigin")
+            if grid_origin is not None:
+                self.grid_origin = grid_origin.text
+        point = element.find(f"{self.ns}Point")
+        if point is not None:
+            self.point = point.text
+        shape = element.find(f"{self.ns}shape")
+        if shape is not None:
+            self.shape = shape.text
+
+
+class GroundOverlay(_Overlay):
+    """
+    This element draws an image overlay draped onto the terrain. The <href>
+    child of <Icon> specifies the image to be used as the overlay. This file
+    can be either on a local file system or on a web server. If this element
+    is omitted or contains no <href>, a rectangle is drawn using the color and
+    LatLonBox bounds defined by the ground overlay.
+    """
+
+    __name__ = "GroundOverlay"
+
+    _altitude = None
+    # Specifies the distance above the earth's surface, in meters, and is
+    # interpreted according to the altitude mode.
+
+    _altitude_mode = "clampToGround"
+    # Specifies how the <altitude> is interpreted. Possible values are:
+    #   clampToGround -
+    #       (default) Indicates to ignore the altitude specification and drape
+    #       the overlay over the terrain.
+    #   absolute -
+    #       Sets the altitude of the overlay relative to sea level, regardless
+    #       of the actual elevation of the terrain beneath the element. For
+    #       example, if you set the altitude of an overlay to 10 meters with an
+    #       absolute altitude mode, the overlay will appear to be at ground
+    #       level if the terrain beneath is also 10 meters above sea level. If
+    #       the terrain is 3 meters above sea level, the overlay will appear
+    #       elevated above the terrain by 7 meters.
+
+    # - LatLonBox -
+    # TODO: Convert this to it's own class?
+    # Specifies where the top, bottom, right, and left sides of a bounding box
+    # for the ground overlay are aligned. Also, optionally the rotation of the
+    # overlay.
+
+    _north = None
+    # Specifies the latitude of the north edge of the bounding box, in decimal
+    # degrees from 0 to ±90.
+
+    _south = None
+    # Specifies the latitude of the south edge of the bounding box, in decimal
+    # degrees from 0 to ±90.
+
+    _east = None
+    # Specifies the longitude of the east edge of the bounding box, in decimal
+    # degrees from 0 to ±180. (For overlays that overlap the meridian of 180°
+    # longitude, values can extend beyond that range.)
+
+    _west = None
+    # Specifies the longitude of the west edge of the bounding box, in decimal
+    # degrees from 0 to ±180. (For overlays that overlap the meridian of 180°
+    # longitude, values can extend beyond that range.)
+
+    _rotation = None
+    # Specifies a rotation of the overlay about its center, in degrees. Values
+    # can be ±180. The default is 0 (north). Rotations are specified in a
+    # counterclockwise direction.
+
+    # TODO: <gx:LatLonQuad>
+    # Used for nonrectangular quadrilateral ground overlays.
+    _lat_lon_quad = None
+
+    @property
+    def altitude(self) -> Optional[str]:
+        return self._altitude
+
+    @altitude.setter
+    def altitude(self, value) -> None:
+        if isinstance(value, (str, int, float)):
+            self._altitude = str(value)
+        elif value is None:
+            self._altitude = None
+        else:
+            raise ValueError
+
+    @property
+    def altitude_mode(self) -> str:
+        return self._altitude_mode
+
+    @altitude_mode.setter
+    def altitude_mode(self, mode) -> None:
+        if mode in ("clampToGround", "absolute"):
+            self._altitude_mode = str(mode)
+        else:
+            self._altitude_mode = "clampToGround"
+
+    @property
+    def north(self) -> Optional[str]:
+        return self._north
+
+    @north.setter
+    def north(self, value) -> None:
+        if isinstance(value, (str, int, float)):
+            self._north = str(value)
+        elif value is None:
+            self._north = None
+        else:
+            raise ValueError
+
+    @property
+    def south(self) -> Optional[str]:
+        return self._south
+
+    @south.setter
+    def south(self, value) -> None:
+        if isinstance(value, (str, int, float)):
+            self._south = str(value)
+        elif value is None:
+            self._south = None
+        else:
+            raise ValueError
+
+    @property
+    def east(self) -> Optional[str]:
+        return self._east
+
+    @east.setter
+    def east(self, value) -> None:
+        if isinstance(value, (str, int, float)):
+            self._east = str(value)
+        elif value is None:
+            self._east = None
+        else:
+            raise ValueError
+
+    @property
+    def west(self) -> Optional[str]:
+        return self._west
+
+    @west.setter
+    def west(self, value) -> None:
+        if isinstance(value, (str, int, float)):
+            self._west = str(value)
+        elif value is None:
+            self._west = None
+        else:
+            raise ValueError
+
+    @property
+    def rotation(self) -> Optional[str]:
+        return self._rotation
+
+    @rotation.setter
+    def rotation(self, value) -> None:
+        if isinstance(value, (str, int, float)):
+            self._rotation = str(value)
+        elif value is None:
+            self._rotation = None
+        else:
+            raise ValueError
+
+    def lat_lon_box(
+        self,
+        north: int,
+        south: int,
+        east: int,
+        west: int,
+        rotation: int = 0,
+    ) -> None:
+        if -90 <= float(north) <= 90:
+            self.north = north
+        else:
+            raise ValueError
+        if -90 <= float(south) <= 90:
+            self.south = south
+        else:
+            raise ValueError
+        if -180 <= float(east) <= 180:
+            self.east = east
+        else:
+            raise ValueError
+        if -180 <= float(west) <= 180:
+            self.west = west
+        else:
+            raise ValueError
+        if -180 <= float(rotation) <= 180:
+            self.rotation = rotation
+        else:
+            raise ValueError
+
+    def etree_element(
+        self,
+        precision: Optional[int] = None,
+        verbosity: Verbosity = Verbosity.normal,
+    ) -> Element:
+        element = super().etree_element(precision=precision, verbosity=verbosity)
+        if self._altitude:
+            altitude = config.etree.SubElement(element, f"{self.ns}altitude")
+            altitude.text = self._altitude
+            if self._altitude_mode:
+                altitude_mode = config.etree.SubElement(
+                    element,
+                    f"{self.ns}altitudeMode",
+                )
+                altitude_mode.text = self._altitude_mode
+        if all([self._north, self._south, self._east, self._west]):
+            lat_lon_box = config.etree.SubElement(element, f"{self.ns}LatLonBox")
+            north = config.etree.SubElement(lat_lon_box, f"{self.ns}north")
+            north.text = self._north
+            south = config.etree.SubElement(lat_lon_box, f"{self.ns}south")
+            south.text = self._south
+            east = config.etree.SubElement(lat_lon_box, f"{self.ns}east")
+            east.text = self._east
+            west = config.etree.SubElement(lat_lon_box, f"{self.ns}west")
+            west.text = self._west
+            if self._rotation:
+                rotation = config.etree.SubElement(lat_lon_box, f"{self.ns}rotation")
+                rotation.text = self._rotation
+        return element
+
+    def from_element(self, element: Element) -> None:
+        super().from_element(element)
+        altitude = element.find(f"{self.ns}altitude")
+        if altitude is not None:
+            self.altitude = altitude.text
+        altitude_mode = element.find(f"{self.ns}altitudeMode")
+        if altitude_mode is not None:
+            self.altitude_mode = altitude_mode.text
+        lat_lon_box = element.find(f"{self.ns}LatLonBox")
+        if lat_lon_box is not None:
+            north = lat_lon_box.find(f"{self.ns}north")
+            if north is not None:
+                self.north = north.text
+            south = lat_lon_box.find(f"{self.ns}south")
+            if south is not None:
+                self.south = south.text
+            east = lat_lon_box.find(f"{self.ns}east")
+            if east is not None:
+                self.east = east.text
+            west = lat_lon_box.find(f"{self.ns}west")
+            if west is not None:
+                self.west = west.text
+            rotation = lat_lon_box.find(f"{self.ns}rotation")
+            if rotation is not None:
+                self.rotation = rotation.text