notebooks/00_demo_mogi.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Geological Interpretor Development"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a notebook for testing and developping some of the basic code in this package."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Some initial imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.spatial as spatial\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import patheffects\n",
    "import pandas as pd\n",
    "import owlready2 as owl\n",
    "class MalissiaBaseError(Exception):\n",
    "    \"\"\"This is the base class for all exceptions of this package\"\"\"\n",
    "    \n",
    "class MalissiaNotImplementedYet(MalissiaBaseError):\n",
    "    \"\"\"This is an exception for features that are not yet implemented\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Geological Knowledge Manager"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**GeologicalKnowledgeManager** may know different instances of **GeologicalKnowledgeFramework**,<br>\n",
    "for example to allow differenciating scenarios or for allowing customisation of knowledge and its formalisation.\n",
    "\n",
    "**GeologicalKnowledgeFramework** provides access to concept definitions for providing knowledge."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import random\n",
    "\n",
    "class GeologicalKnowledgeManager(object):\n",
    "    \"\"\"GeologicalKnowledgeManager is managing one or several GeologicalKnowledgeFramework.\n",
    "    \n",
    "    The GeologicalKnowledgeManager is typically a singleton, so there is always one and only one instance of it.\n",
    "    \n",
    "    The GeologicalKnowledgeManager may know different instances of GeologicalKnowledgeFramework,\n",
    "    for example to allow different interpretation scenarios or for allowing user-specific customisation\n",
    "    of knowledge and its formalisation.\n",
    "    \n",
    "    GeologicalKnowledgeFramework are typically ontologies and extensions defined in this package or elsewhere.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __new__(cls):\n",
    "        \"\"\"Method to access (and create if needed) the only allowed instance of this class.\n",
    "        \n",
    "        Returns:\n",
    "        - an instance of GeologicalKnowledgeManager\"\"\"\n",
    "        if not hasattr(cls, 'instance'):\n",
    "            cls.instance = super(GeologicalKnowledgeManager, cls).__new__(cls)\n",
    "            cls.initialised= False\n",
    "        return cls.instance\n",
    "        \n",
    "    def __init__(self, default= \"mogi\", default_source_directory= \"../ontologies/\", default_source_file= \"mogi.owl\", default_ontology_backend= \"owlready2\"):\n",
    "        \"\"\"Initializes the GeologicalKnowledgeManager with some default values from configuration.\n",
    "        \n",
    "        Parameters:\n",
    "        - default: specifies the name of the default knowledge framework\n",
    "        - default_source_directory: specifies the default folder containing of the knowledge framework definitions\n",
    "        - default_source_file: file contained in the source_directory defining the knowledge framework (e.g., .owl file)\n",
    "        - default_ontology_backend: specifies the default ontology backend to be used\n",
    "        \"\"\"\n",
    "        if not self.initialised:\n",
    "            self._initialise(default= default, default_source_directory= default_source_directory, default_source_file= default_source_file, default_ontology_backend= default_ontology_backend)\n",
    "            \n",
    "    def _initialise(self, default, default_source_directory, default_source_file, default_ontology_backend):\n",
    "        \"\"\"Initializes the GeologicalKnowledgeManager with some default values from configuration.\n",
    "        \n",
    "        Parameters:\n",
    "        - default: specifies the name of the default knowledge framework\n",
    "        - default_source_directory: specifies the default folder containing of the knowledge framework definitions\n",
    "        - default_source_file: file contained in the source_directory defining the knowledge framework (e.g., .owl file)\n",
    "        - default_ontology_backend: specifies the default ontology backend to be used\n",
    "        \"\"\"\n",
    "        self.default= default\n",
    "        self.default_source_directory= default_source_directory\n",
    "        self.default_source_file= default_source_file\n",
    "        self.default_ontology_backend= default_ontology_backend\n",
    "        \n",
    "        self.knowledge_framework_dict = {}\n",
    "        \n",
    "        self.initialised= True\n",
    "        \n",
    "    def reset(self, default= \"mogi\", default_source_directory= \"../ontologies/\", default_source_file= \"mogi.owl\", default_ontology_backend= \"owlready2\"):\n",
    "        \"\"\"Reinitializes the GeologicalKnowledgeManager with some default values from configuration.\n",
    "        \n",
    "        Parameters:\n",
    "        - default: specifies the name of the default knowledge framework\n",
    "        - default_source_directory: specifies the default folder containing of the knowledge framework definitions\n",
    "        - default_source_file: file contained in the source_directory defining the knowledge framework (e.g., .owl file)\n",
    "        - default_ontology_backend: specifies the default ontology backend to be used\n",
    "        \"\"\"\n",
    "        self._initialise(default= default, default_source_directory= default_source_directory, default_source_file= default_source_file, default_ontology_backend= default_ontology_backend)\n",
    "             \n",
    "    def load_knowledge_framework(self, name=None, source= None, source_directory= None, backend= None):\n",
    "        \"\"\"Gets and initilises the ontology from the specified source.\n",
    "        \n",
    "        Parameters:\n",
    "        - name: the name to be given to the knowledge framework. If None (default) the file name will be used.\n",
    "        - source: filename to the ontology source. If None(default) the default ontology is used.\n",
    "        - source_directory: where the system should look for ontology definition files. If None, the `GeologicalKnowledgeFramework` will decide.\n",
    "        - backend: the ontology backend to be used. If None, the `GeologicalKnowledgeFramework` will decide.\"\"\"\n",
    "        source = source if source is not None else self.default_source_file\n",
    "        name = name if name is not None else os.path.basename(source).split(os.path.extsep)[0]\n",
    "        self.knowledge_framework_dict[name] = GeologicalKnowledgeFramework(name= name, source= source, source_directory= source_directory, backend= backend)\n",
    "    \n",
    "    def get_knowledge_framework(self,name= \"default\"):\n",
    "        \"\"\"Accessor to knowledge frameworks.\"\"\"\n",
    "        name = self.default if name == \"default\" else name\n",
    "        assert len(self.knowledge_framework_dict) > 0, \"No ontology has been loaded yet. Please use GeologicalKnowledgeManager().load_knowledge_framework() first\"\n",
    "        assert name in self.knowledge_framework_dict.keys(), \"The specified ontology hasn't been loaded: \"+name+\\\n",
    "            \"\\navailable ontology names are: \"+\"\\n\".join(self.knowledge_framework_dict.keys())\n",
    "        return self.knowledge_framework_dict[name]\n",
    "    \n",
    "class GeologicalKnowledgeFramework(object):\n",
    "    \"\"\"A GeologicalKnowledgeFramework holds the definition of concepts and relationships describing knowledge.\n",
    "    \n",
    "    This is typically an overlay around a formal ontology definition, which also brings additional capabilities,\n",
    "    such as algorithms and factories to achieve specific tasks and create objects.\n",
    "    \n",
    "    This knowledge framework also holds \n",
    "\n",
    "    - a registry of available constructors for making new objects:\n",
    "     -- registered_constructors: a dictionnary holding the constructors for a given class, sorted in order of preference,\n",
    "         structured as {class_object or key: [constructor1, constructor2,...]}\n",
    "     -- constructor_conditions: conditions for the application of a constructor,\n",
    "       e.g., regarding InterpretationSituation, interpretor status, and parameters.\n",
    "        Structured as dictionnaries {constructor: function_to_evaluate_conditions}\n",
    "\n",
    "    - a registry of available evaluators for evaluating objects:\n",
    "     -- registered_constructors: a dictionnary holding the evaluators for a given class, sorted in order of preference,\n",
    "         structured as {class_object or key: [evaluator1, evaluator2,...]}\n",
    "\n",
    "    - a registry of available updaters for making new objects:\n",
    "     -- registered_constructors: a dictionnary holding the updaters for a given class, sorted in order of preference,\n",
    "         structured as {class_object or key: [updater1, updater2,...]}\n",
    "     -- updater_conditions: conditions for the application of an updater,\n",
    "       e.g., regarding InterpretationSituation, interpretor status, and parameters.\n",
    "        Structured as dictionnaries {updater: function_to_evaluate_updaters}\n",
    "\n",
    "    \n",
    "        \"\"\"\n",
    "\n",
    "\n",
    "    # registry of object constructors and conditions\n",
    "    registered_constructors = {}\n",
    "    constructor_conditions = {}\n",
    "    \n",
    "    # registry of evaluators\n",
    "    registered_internal_consistency_evaluation = {}\n",
    "    registered_explanation_consistency_evaluation = {}\n",
    "\n",
    "    # registry of updaters and conditions\n",
    "    registered_updaters = {}\n",
    "    updater_conditions = {}\n",
    "\n",
    "    \n",
    "    def __init__(self, name, source, source_directory= None, backend= None):\n",
    "        \"\"\"Initialise a KnowledgeFramework form a given ontology file (source).\n",
    "        \n",
    "        Parameters:\n",
    "        - name: should be the name under which this KnowledgeFramework is known in the manager\n",
    "        - source: the source file for the ontology definition\n",
    "        - source_directory: the directory where the source files for the ontology definition are looked for.\n",
    "        If None (default) the default path provided by the `KnowledgeManager` is used.\n",
    "        - backend: the ontology backend to be used for this knwoledge framework.\n",
    "        If None (default) the default ontology backend provided by the `KnowledgeManager` is used.\"\"\"\n",
    "        self.name= name\n",
    "        \n",
    "        self._source_directory= None\n",
    "        self.init_source_directory(source_directory)\n",
    "        self.initialise_ontology_backend(backend)\n",
    "        \n",
    "        self.load_ontology(source)\n",
    "            \n",
    "    \n",
    "    def init_source_directory(self, source_directory):\n",
    "        \"\"\"Initialises the folder where source files are searched.\n",
    "        \n",
    "        Parameters:\n",
    "        - source_directory: if None, the previous value is used if it wasn't None, else the `GeologicalKnowledgeManager`default is used.\"\"\"\n",
    "        if source_directory is not None:\n",
    "            self._source_directory= source_directory\n",
    "        elif self._source_directory is None:\n",
    "            self._source_directory= GeologicalKnowledgeManager().default_source_directory\n",
    "    \n",
    "    def initialise_ontology_backend(self, backend_name:str= None):\n",
    "        \"\"\"Initializes the ontology package used as a backend to access ontologies.\n",
    "        \n",
    "        This will:\n",
    "        - try to import the backend as onto\n",
    "        - set the default path for ontologies\"\"\"\n",
    "                \n",
    "        self._ontology_backend = None\n",
    "        backend_name= GeologicalKnowledgeManager().default_ontology_backend if backend_name is None else backend_name\n",
    "        if backend_name == \"owlready2\":\n",
    "            try:\n",
    "                import owlready2 as owl2 \n",
    "                self._ontology_backend = owl2\n",
    "                if self._source_directory not in self._ontology_backend.onto_path:\n",
    "                    self._ontology_backend.onto_path.append(self._source_directory)\n",
    "            except ImportError:\n",
    "                raise ImportError(\"Your are trying to use Owlready2 as a backend for ontology management, but it doesn't appear to be installed.\"\\\n",
    "                \"This is either because OwlReady2 is given as default option or because you asked for it.\"\\\n",
    "                \"Please install the OwlReady2 package from https://owlready2.readthedocs.io\"\\\n",
    "                \"or give another backend through GeologicalKnowledgeManager().initialise_ontology_backend()\")\n",
    "                \n",
    "            # also test if java is correctly installed & accessible, as it is used by owlready2 for reasoning\n",
    "            try:\n",
    "                os.system(\"java -version\")\n",
    "            except:\n",
    "                raise ImportError(\"Java doesn't appear to be installed properly as the command `java -version` returned an error.\"\\\n",
    "                    \"This error occured while loading owlready2 package as an ontology backend, because java is used for the reasoning engine.\")\n",
    "        else:\n",
    "            raise Exception(\"The specified backed for ontology is not supported: \"+backend_name)\n",
    "          \n",
    "        \n",
    "    def load_ontology(self, source):\n",
    "        \"\"\"Loads the ontology specified by source.\n",
    "        \n",
    "        Parameters:\n",
    "        - source: the source file for the ontology definition\n",
    "        - source_directory: the directory where the source files for the ontology definition are looked for.\n",
    "        If None (default) the default path provided by the `KnowledgeManager` is used.\"\"\"\n",
    "        self._source= source\n",
    "        try:\n",
    "            self._onto = self._ontology_backend.get_ontology(self._source).load()\n",
    "        except Exception as err:\n",
    "            raise Exception(\"Unexpected exception received while loading ontology:\\n - source: {}\\n - onto_path: {}\".format(self._source, self._ontology_backend.onto_path))\n",
    "        \n",
    "    def __call__(self):\n",
    "        return self._onto\n",
    "        \n",
    "    def get_ontology_backend(self):\n",
    "        \"\"\"Gets the ontology backend\"\"\"\n",
    "        assert self._ontology_backend is not None, \"Trying to access the ontology backend without initialising it.\"\n",
    "        return self._ontology_backend\n",
    "    \n",
    "    def search(self, name= None, type= None, qualities= None, prepend_star=True) -> list:\n",
    "        \"\"\"Search function to interface the serach capabilities of the internal ontology\n",
    "        \n",
    "        Parameters:\n",
    "        - name: the name of the search object (you can use * to replace any set of characters and ? to replace any single character)\n",
    "        Note: if `prepend_star` a * is always prepended to allows the search to work because of the internal prefix names\n",
    "        - type: the type of the searched observations as defined by the internal ontology\n",
    "        - qualities: qualities to filter the observations.\n",
    "        If `qualities` is a :\n",
    "         * `str`: a single quality will be searched for with any value (\"*\"),\n",
    "         * `list`: a list of qualities will be searched for with any values (\"*\")\n",
    "         * `dict`: a list of qualities defined by the keys and with the associated values will be searched for\"\"\"\n",
    "        if name is None:\n",
    "            name = \"*\"\n",
    "        elif prepend_star:\n",
    "            name = \"*\"+name\n",
    "        \n",
    "        if isinstance(qualities,list):\n",
    "            kargs = {quality_i: \"*\" for quality_i in qualities} \n",
    "        elif isinstance(qualities,str):\n",
    "            kargs = {qualities: \"*\"}\n",
    "        elif isinstance(qualities,dict):\n",
    "            kargs = qualities\n",
    "        else:\n",
    "            kargs = {}\n",
    "            assert (qualities is None) or isinstance(qualities,dict), \"qualities should be given as either None, a str, a list, or a dict\"\n",
    "        if type is not None: kargs[\"type\"] = type\n",
    "        return self._onto.search(iri= name, **kargs)\n",
    "    \n",
    "    def format_qualities(self, **qualities):\n",
    "        \"\"\"Formats the qualities for setting an instance\n",
    "\n",
    "        It will :\n",
    "         - remove qualities that are not defined in the ontology\n",
    "         - transform scalar values into vectors (for non functional properties)\n",
    "         - filter out None values\n",
    "        \"\"\"\n",
    "        \n",
    "        formated_qualities = {key:val for key, val in qualities.items() \n",
    "                 if (val is not None) and (getattr(self._onto,key) is not None)\n",
    "                 }\n",
    "        for key, val in formated_qualities.items():\n",
    "            if not getattr(self._onto,key).is_functional_for(None):\n",
    "                formated_qualities[key] = val if isinstance(val,list) else [val]\n",
    "        return formated_qualities\n",
    "\n",
    "    def create_instance(self, class_type, name = None, physical_space= None, warning= False, **qualities):\n",
    "        \"\"\"Creates an instance in the ontology\n",
    "        \n",
    "        Parameters:\n",
    "        - class_type: the type of the class of the object to be created (as in the ontology, e.g., mogi().Surface).\n",
    "        Note: the given class_type must be in the internal ontology stored in this manager.\n",
    "        - name: a string giving the name of the object. If None (default) this name is set automatically\n",
    "        - physical_space: if defined, a PhysicalSpaceRepresentation that handles the spatial qualities given in qualities\n",
    "        - qualities: a series of possible qualities to be added to the object\"\"\"\n",
    "        if class_type not in self._onto.classes():\n",
    "            raise MalissiaBaseError(\"The proposed class type ({}) does not belong to this ontology ({})\".format(class_type, self._onto))\n",
    "            \n",
    "        # checking name\n",
    "        if name == \"\":\n",
    "            if warning: logging.warning(\"Trying to create a '{}' with a blank name, passing None instead.\".format(class_type))\n",
    "            name = None\n",
    "        if not isinstance(name,str):\n",
    "            if warning: logging.warning(\"Trying to create a '{}' with a name that is not a string, using default naming instead.\".format(class_type))\n",
    "            name = None\n",
    "\n",
    "        #reformating the qualities\n",
    "        \n",
    "        formated_qualities = self.format_qualities(**qualities)\n",
    "        if physical_space:\n",
    "            non_coordinate_qualities = physical_space.filter_qualities(**formated_qualities)\n",
    "            new_individual = class_type(name= name, **non_coordinate_qualities)\n",
    "            physical_space.set_object_coordinates(new_individual, **qualities)\n",
    "        else:\n",
    "            new_individual = class_type(name= name, **formated_qualities)\n",
    "\n",
    "        return new_individual\n",
    "    \n",
    "    def modify_instance_properties(self, instance, **kwargs):\n",
    "        \"\"\"at this stage, the user of this metod must know if\n",
    "            the prop is functionnal which means one value, or non\n",
    "            functional and the value or values must be introduced in a list \"\"\"\n",
    "        # add maybe types checking methods / and method to verify if is_functional_for\n",
    "        for key, value in kwargs.items():\n",
    "            prop_name = str(key)\n",
    "            setattr(instance, prop_name, value)\n",
    "        return instance\n",
    "\n",
    "    \n",
    "    def copy_individual(self, original_instance, name_of_copied_individual=None, \n",
    "                        visited=None, dict_of_copied_individuals = None):\n",
    "        if dict_of_copied_individuals is None:\n",
    "            dict_of_copied_individuals = {}\n",
    "\n",
    "        if visited is None:\n",
    "            visited = set()\n",
    "\n",
    "        if original_instance in visited:\n",
    "            if original_instance.name not in dict_of_copied_individuals:\n",
    "                raise MalissiaBaseError('the instance {} is visited but not copied !'.format(original_instance.name))\n",
    "            return original_instance, dict_of_copied_individuals[original_instance.name]\n",
    "\n",
    "        if original_instance not in visited:\n",
    "            visited.add(original_instance)\n",
    "            sign = True if original_instance.name in dict_of_copied_individuals else False\n",
    "            associa_prop = original_instance.get_properties()\n",
    "            associa_prop\n",
    "            dict_of_prop = {}\n",
    "            for prop in associa_prop:\n",
    "                dict_of_prop[prop.name] = getattr(original_instance, prop.name)\n",
    "            copied_individual, dict_of_copied_individuals = self.copy_an_instance_with_direct_qualities(instance_to_copy = original_instance,\n",
    "                                                            already_copied_individual_but_not_related_individuals = sign,\n",
    "                                                            dict_of_copied_individuals = dict_of_copied_individuals,\n",
    "                                                            name_of_copied_individual = None,\n",
    "                                                            **dict_of_prop ) \n",
    "            for key, value in dict_of_copied_individuals.items():\n",
    "                original_instance, copy = self.copy_individual(\n",
    "                   'value' , name_of_copied_individual=None,  # if the value is used it enters in an endles loop\n",
    "                        visited=visited, dict_of_copied_individuals = dict_of_copied_individuals)\n",
    "                if original_instance.name not in  dict_of_copied_individuals:\n",
    "                    dict_of_copied_individuals[original_instance.name ] = copy\n",
    "                if value not in visited:\n",
    "                    visited.add(value)\n",
    "                \n",
    "            return   original_instance, dict_of_copied_individuals[original_instance.name]\n",
    "                        \n",
    "    def copy_an_instance_with_direct_qualities(self, instance_to_copy, \n",
    "                                               already_copied_individual_but_not_related_individuals = False,\n",
    "                                               dict_of_copied_individuals = None,\n",
    "                                               name_of_copied_individual = None,\n",
    "                                                **kwargs ):\n",
    "        \n",
    "        if dict_of_copied_individuals is None:\n",
    "            dict_of_copied_individuals = {}\n",
    "        if instance_to_copy.name not in dict_of_copied_individuals :\n",
    "            name_of_copied_individual = str(name_of_copied_individual) if \\\n",
    "                                                name_of_copied_individual is not None \\\n",
    "                                                            else f'copy_of_{instance_to_copy.name}'\n",
    "\n",
    "            # Copy the individual\n",
    "            if len(instance_to_copy.is_instance_of) >= 1:\n",
    "                class_of_the_instance = instance_to_copy.is_instance_of[0] if type(instance_to_copy.is_instance_of[0]) \\\n",
    "                    != owl.Thing else original_instance.is_instance_of[1]\n",
    "                copied_individual = class_of_the_instance(name=name_of_copied_individual)\n",
    "                for cls in instance_to_copy.is_instance_of:\n",
    "                    if cls == class_of_the_instance:\n",
    "                        pass\n",
    "                    else:\n",
    "                        copied_individual.is_instance_of.append(cls)\n",
    "                dict_of_copied_individuals[instance_to_copy.name] = copied_individual\n",
    "\n",
    "                for key,  value in kwargs.items():\n",
    "                    if type(getattr(self(), key)) == owl.ObjectPropertyClass and \\\n",
    "                                                            len(getattr(instance_to_copy, key)) >0 :\n",
    "                        related_individuals = getattr(instance_to_copy, key)\n",
    "                        related_copied_individuals = set()\n",
    "                        for related in related_individuals:\n",
    "                            class_of_the_related = related.is_instance_of[0] if type(related.is_instance_of[0]) != owl.Thing else related.is_instance_of[1]\n",
    "                            name_of_copied_related = str('copy_of_{}'.format(related.name))\n",
    "                            copied_related = class_of_the_related(name=name_of_copied_related)\n",
    "                            for cls in related.is_instance_of:\n",
    "                                if cls == class_of_the_related:\n",
    "                                    pass\n",
    "                                else:\n",
    "                                    copied_related.is_instance_of.append(cls)\n",
    "                            if copied_related not in  related_copied_individuals:\n",
    "                                related_copied_individuals.add(copied_related)\n",
    "                            if related.name not in dict_of_copied_individuals:\n",
    "                                dict_of_copied_individuals[related.name] = copied_related\n",
    "                        setattr(copied_individual, key, list(related_copied_individuals)) \n",
    "\n",
    "                for key,  value in kwargs.items():\n",
    "                    if type(getattr(self(), key)) == owl.DataPropertyClass and \\\n",
    "                                    len(getattr(instance_to_copy, key)) >0 :\n",
    "                        setattr(copied_individual, key, value )\n",
    "            return copied_individual, dict_of_copied_individuals\n",
    "        \n",
    "        elif instance_to_copy.name  in dict_of_copied_individuals and \\\n",
    "            already_copied_individual_but_not_related_individuals == False:\n",
    "\n",
    "            copied_individual = dict_of_copied_individuals[instance_to_copy.name]\n",
    "            for key,  value in kwargs.items():\n",
    "                if type(getattr(self(), key)) == owl.ObjectPropertyClass and \\\n",
    "                                                        len(getattr(instance_to_copy, key)) >0 :\n",
    "                    related_individuals = getattr(instance_to_copy, key)\n",
    "                    related_copied_individuals = set()\n",
    "                    for related in related_individuals:\n",
    "                        class_of_the_related = related.is_instance_of[0] if type(related.is_instance_of[0]) != owl.Thing else related.is_instance_of[1]\n",
    "                        name_of_copied_related = str('copy_of_{}'.format(related.name))\n",
    "                        copied_related = class_of_the_related(name=name_of_copied_related)\n",
    "                        for cls in related.is_instance_of:\n",
    "                            if cls == class_of_the_related:\n",
    "                                pass\n",
    "                            else:\n",
    "                                copied_related.is_instance_of.append(cls)\n",
    "                        if copied_related not in  related_copied_individuals:\n",
    "                            related_copied_individuals.add(copied_related)\n",
    "                        if related.name not in dict_of_copied_individuals:\n",
    "                            dict_of_copied_individuals[related.name] = copied_related\n",
    "                    setattr(copied_individual, key, list(related_copied_individuals)) \n",
    "\n",
    "            for key,  value in kwargs.items():\n",
    "                if type(getattr(self(), key)) == owl.DataPropertyClass and \\\n",
    "                                len(getattr(instance_to_copy, key)) >0 :\n",
    "                    setattr(copied_individual, key, value )\n",
    "            return copied_individual, dict_of_copied_individuals\n",
    "        elif instance_to_copy.name  in dict_of_copied_individuals and \\\n",
    "            already_copied_individual_but_not_related_individuals == True:\n",
    "            return dict_of_copied_individuals[instance_to_copy.name], dict_of_copied_individuals\n",
    "\n",
    "    \n",
    "    def remove_instance(self, instance):\n",
    "        self._ontology_backend.destroy_entity(instance)\n",
    "        \n",
    "    def remove_all_instances(self, instances = None):\n",
    "        if instances is None:\n",
    "            instances = self._onto.individuals()\n",
    "        for instance in instances:\n",
    "            self.remove_instance(instance)\n",
    "        \n",
    "    def get_all_classes_of_instance(self,instance):\n",
    "        \"\"\"Returns all the classes of this instance and all its ancestors\n",
    "        \n",
    "        Parameters:\n",
    "        - instance: an instance to be investigated\n",
    "        Returns:\n",
    "        - a set containing all the classes this instance belongs to including the mother classes\n",
    "        Note: be carefull because this is returnin owl.Thing too and may cause issues if not handled\n",
    "        \"\"\"\n",
    "        instance_classes = set(instance.is_instance_of)\n",
    "        instance_classes.discard(self._ontology_backend.Thing)\n",
    "        return set.union(*[instance_class.ancestors() for instance_class in instance_classes])\n",
    "        \n",
    "    def show_instance_qualities(self,instance):\n",
    "        if instance is None: \n",
    "            print(\"The instance is None.\")\n",
    "            return\n",
    "        print(\"instance:\",instance)\n",
    "        print(\"types:\", \",\".join([str(i) for i in instance.is_a]))\n",
    "        print(\"properties:\")\n",
    "        for prop in instance.get_properties():\n",
    "            print(\"|- {}:{}\".format(prop.name, prop[instance]))\n",
    "            \n",
    "    def get_all_instances(self):\n",
    "        return list(self._onto.individuals())\n",
    "    \n",
    "    def show_all_instance_qualities(self, instances= None):\n",
    "        instances = instances if instances is not None else self.get_all_instances()\n",
    "        print(\"Number of instances:\",len(instances))\n",
    "        for i in instances:\n",
    "            self.show_instance_qualities(i)\n",
    "            \n",
    "    def has_quality(self, object, quality):\n",
    "        return getattr(self._onto, quality) in object.get_properties()\n",
    "    \n",
    "    def has_qualities(self, object, qualities):\n",
    "        qualities = np.array(qualities).ravel()\n",
    "        return np.all([self.has_quality(object, quality_i) for quality_i in qualities])\n",
    "            \n",
    "    def get_possible_interpretations_of(self, object):\n",
    "        \"\"\"Returns a list of classes potentially explaining this object\"\"\"\n",
    "        object_classes = object.is_instance_of\n",
    "        if len(object_classes) == 0:\n",
    "            raise MalissiaBaseError(\"Trying to interprete an object without class.\")\n",
    "        possible_interpretations = [interpretation for class_i in object_classes \n",
    "                                    for interpretation in class_i.has_Possible_Explanation ] \n",
    "        return possible_interpretations\n",
    "        \n",
    "    def get_objects_potentially_explained_by(self, object):\n",
    "        \"\"\"Returns the classes this object is potentially explaining.\"\"\"\n",
    "        return object.is_Possible_Explanation_Of\n",
    "    \n",
    "    def isinstance(self, candidate_object, candidate_class):\n",
    "        \"\"\"Checks whether an object is an instance of a given class\"\"\"\n",
    "        return isinstance(candidate_object, candidate_class)\n",
    "    \n",
    "    def issubclass(self, candidate_subclass, candidate_class):\n",
    "        \"\"\"Checks whether an object is an instance of a given class\"\"\"\n",
    "        return issubclass(candidate_subclass, candidate_class)\n",
    "    \n",
    "    def has_representation_of_type(self, candidate_object, representation_type, return_representations= False):\n",
    "        \"\"\"Checks if an instance has a representation of a given type\"\"\"\n",
    "        if (candidate_object.has_Representation is None) or (len(candidate_object.has_Representation) < 1):\n",
    "            return False\n",
    "        reps = np.array(candidate_object.has_Representation)\n",
    "        selected_representations = [self.isinstance(rep_i, representation_type) for rep_i in reps]\n",
    "        if return_representations:\n",
    "            return reps[selected_representations]\n",
    "        else:\n",
    "            return np.any(selected_representations)\n",
    "        \n",
    "    def has_point_representation(self, candidate_object, return_representations= False):\n",
    "        return self.has_representation_of_type(candidate_object, self._onto.Point, return_representations)\n",
    "    \n",
    "    @classmethod\n",
    "    def register_constructor(cls, object_class_name, constructor, condition = None):\n",
    "        \"\"\"Registers a constructor for the given ontology class\n",
    "        \n",
    "        Parameters:\n",
    "        - object_class_name: the type of object to be created (typically, the ontology class name)\n",
    "        - constructor: a function that can be called to generate the given object class.\n",
    "          It will typically be method of the GeologicalKnowledgeFramework and called by\n",
    "          constructor( knowledge_framework= None, interpretation_situation = None, interpretation_status = None, **kargs)\n",
    "        \"\"\"\n",
    "        if (object_class_name is None) or (not isinstance(object_class_name, str)):\n",
    "            raise MalissiaBaseError(\"Registering constructor for an undefined object class.\")\n",
    "        if constructor is None: raise MalissiaBaseError(\"Registering  an undefined constructor for an object class.\")\n",
    "        \n",
    "        if object_class_name in cls.registered_constructors:\n",
    "            cls.registered_constructors[object_class_name] += [constructor]\n",
    "        else:\n",
    "            cls.registered_constructors[object_class_name] = [constructor]\n",
    "        cls.constructor_conditions[constructor] = condition\n",
    "            \n",
    "    def filter_explainable_features(self, object_class, features):\n",
    "        \"\"\"Selects the features that can be explained by a given ontology class.\n",
    "        \n",
    "        Parameters:\n",
    "        - object_class [object]: a type of object used as an explanation\n",
    "        - features: the list of features to be filtered.\n",
    "        Returns:\n",
    "        - a list of features that can be explained by the proposed class\"\"\"\n",
    "        explainable_class_set = set(self.get_objects_potentially_explained_by(object_class))\n",
    "        return [feature_i for feature_i in features \n",
    "                if not self.get_all_classes_of_instance(feature_i).isdisjoint(explainable_class_set)]\n",
    "                # test wether the is an intersection between the classes of the instance and the explainable classes\n",
    "    \n",
    "    def filter_explainable_features_by_type(self, features, type_of_feature = 'any'):\n",
    "        \"\"\"filter list of features according to a given type. Returns all if noe type is specified.\n",
    "        \n",
    "        Parameters:\n",
    "        - features: the list of features to be filtered.\n",
    "        - type_of_feature = an ontology object designating which type of features to retain\n",
    "        \"\"\"\n",
    "        if type_of_feature == 'any':\n",
    "            return features\n",
    "        features =  [feature_i for feature_i in features if isinstance(feature_i, type_of_feature)]\n",
    "        return features\n",
    "\n",
    "    def filter_explainable_features_by_number(self, features, nb_feature = 0):\n",
    "        \"\"\"Select a given number of features.\n",
    "        \n",
    "        Parameters:\n",
    "        - features: the list of features to be filtered.\n",
    "        Returns:\n",
    "        - a list of nb features \"\"\"\n",
    "        if len(features) == 0 :\n",
    "            print(\"Warning: Not enough explainable features in {}. To be implemented.\".format(features))\n",
    "            return None\n",
    "        if nb_feature == 0:\n",
    "            return features\n",
    "        else:\n",
    "            if len(features) < 2 :\n",
    "                print(\"Warning: Not enough explainable features in {}. To be implemented.\".format(features))\n",
    "                return None\n",
    "            else: \n",
    "                return random.sample(features, 2)\n",
    "        \n",
    "    def select_object_constructor(self, object_class_name, \n",
    "                                    interpretation_situation = None,\n",
    "                                    interpretation_status = None,\n",
    "                                    random_choice = False,\n",
    "                                    debug= False,\n",
    "                                    **kargs):\n",
    "        \"\"\"Factory function that generates a constructor for the given ontology class\n",
    "        \n",
    "        Parameters:\n",
    "        - object_class_name: the type of object to be created (typically, the ontology class name)\n",
    "        - interpretation_situation: a `InterpretationSituation` providing a context for the creation\n",
    "        - interpretation_status: the status of the current interpretation process,\n",
    "        which might provide contextual information to decide which constructor to generate\n",
    "        - random_choice: if False (default), the first available constructor is selected, else it is picked randomly\n",
    "        - debug: if True, some debug information is sent, default False. \n",
    "        - kargs: keyword arguments passing available qualities and properties.\n",
    "        This will be used to check whether required information is available.\n",
    "        \n",
    "        Return:\n",
    "        - a function that can be called for creating a new instance of the given object.\n",
    "        \"\"\"\n",
    "        object_class_name = object_class_name if isinstance(object_class_name,str) else object_class_name.name\n",
    "        if debug:\n",
    "            print(\"Looking for a constructor for:\", object_class_name)\n",
    "            print(\" - registered constructors:\\n\", \"\\n\".join([str(constructor) for constructor in self.registered_constructors[object_class_name]]))\n",
    "        if object_class_name not in self.registered_constructors:\n",
    "            raise MalissiaBaseError(\"No available constructor for {}.\".format(object_class_name))\n",
    "        \n",
    "        candidate_constructors = [constructor for constructor in self.registered_constructors[object_class_name]\n",
    "                                  if self.constructor_conditions[constructor](\n",
    "                                        knowledge_framework = self,\n",
    "                                        interpretation_situation = interpretation_situation,\n",
    "                                        interpretation_status = interpretation_status,\n",
    "                                        **kargs)\n",
    "                                  ]\n",
    "        if debug:\n",
    "            print(\" - candidate constructors:\\n\", \"\\n\".join([str(constructor) for constructor in candidate_constructors]))\n",
    "        if len(candidate_constructors) == 0:\n",
    "            raise MalissiaBaseError(\"No available constructor for {} in these conditions.\".format(object_class_name))\n",
    "        \n",
    "        selected_constructor = random.choice(candidate_constructors) if random_choice else candidate_constructors[0]\n",
    "        if debug: print(\"Selected constructor:\",str(selected_constructor))\n",
    "        return selected_constructor\n",
    "        \n",
    "        \n",
    "    @classmethod\n",
    "    def register_internal_consistency_evaluator(cls, object_class_name, method):\n",
    "        \"\"\"Registers an evaluation method for internal consistency for the given ontology class\n",
    "        \n",
    "        Parameters:\n",
    "        - object_class_name: the type of object to be created (typically, the ontology class name)\n",
    "        - method: a function that can be called to evaluate internal consistency of the given object class.\n",
    "        \"\"\"\n",
    "        if (object_class_name is None) or (not isinstance(object_class_name, str)):\n",
    "            raise MalissiaBaseError(\"Registering evaluator for an undefined object class.\")\n",
    "        if method is None: raise MalissiaBaseError(\"Registering  an undefined evaluator for an object class.\")\n",
    "        \n",
    "        cls.registered_internal_consistency_evaluation[object_class_name] = method\n",
    "    \n",
    "    def get_internal_consistency_evaluation_method(self, object_class_name):\n",
    "        if not(isinstance(object_class_name, str)):\n",
    "            object_class_name = type(object_class_name).name\n",
    "        return self.registered_internal_consistency_evaluation[object_class_name]\n",
    "    \n",
    "    def evaluate_internal_consistency(self, object, **kargs):\n",
    "        method = self.get_internal_consistency_evaluation_method(object)\n",
    "        return method(object, self, **kargs)\n",
    "    \n",
    "    @classmethod\n",
    "    def register_explanation_consistency_evaluator(cls, object_class_name, method):\n",
    "        \"\"\"Registers an evaluation method for explanation consistency for the given ontology class\n",
    "        \n",
    "        Parameters:\n",
    "        - object_class_name: the type of object to be created (typically, the ontology class name)\n",
    "        - method: a function that can be called to evaluate explanation consistency of the given object class.\n",
    "        \"\"\"\n",
    "        if (object_class_name is None) or (not isinstance(object_class_name, str)):\n",
    "            raise MalissiaBaseError(\"Registering evaluator for an undefined object class.\")\n",
    "        if method is None: raise MalissiaBaseError(\"Registering  an undefined evaluator for an object class.\")\n",
    "        \n",
    "        cls.registered_explanation_consistency_evaluation[object_class_name] = method\n",
    "    \n",
    "    def get_explanation_consistency_evaluation_method(self, object_class_name):\n",
    "        if not(isinstance(object_class_name, str)):\n",
    "            object_class_name = type(object_class_name).name\n",
    "        return self.registered_explanation_consistency_evaluation[object_class_name]\n",
    "    \n",
    "    def evaluate_explanation_consistency(self, object, **kargs):\n",
    "        method = self.get_explanation_consistency_evaluation_method(object)\n",
    "        return method(object, self, **kargs)\n",
    "    \n",
    "    def sync_reasoner(self, **kargs):\n",
    "        \"\"\"Synchronise the reasoner.\n",
    "        \n",
    "        Parameters:\n",
    "        - **kargs:\n",
    "        |- infer_property_values\"\"\"\n",
    "        self._ontology_backend.sync_reasoner(**kargs)\n",
    "        \n",
    "    def __str__(self):\n",
    "        \"\"\"Describe the knowledge framework\"\"\"\n",
    "        desc = [\"Geological Knowledge Framework:\"]\n",
    "        desc += [\" |- Name: {}\".format(self.name)]\n",
    "        desc += [\" |- Backend: {}\".format(self._ontology_backend)]\n",
    "        desc += [\" |- Source: {}\".format(self._source)]\n",
    "        desc += [\" |- Ontology: {}\".format(self._onto)]\n",
    "        return \"\\n\".join(desc)\n",
    "    \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    @classmethod\n",
    "    def register_updater(cls, object_class_name, updater, condition = None):\n",
    "        \"\"\"Registers an updater for the given ontology class\n",
    "        \n",
    "        Parameters:\n",
    "        - object_class_name: the type of object to be updated (typically, the ontology class name)\n",
    "        - constructor: a function that can be called to updated the given object class.\n",
    "        \"\"\"\n",
    "\n",
    "        if (object_class_name is None) or (not isinstance(object_class_name, str)):\n",
    "            raise MalissiaBaseError(\"Registering constructor for an undefined object class.\")\n",
    "        if updater is None: raise MalissiaBaseError(\"Registering  an undefined updater for an object class.\")\n",
    "        \n",
    "        if object_class_name in cls.registered_updaters:\n",
    "            cls.registered_updaters[object_class_name] += [updater]\n",
    "        else:\n",
    "            cls.registered_updaters[object_class_name] = [updater]\n",
    "        cls.updater_conditions[updater] = condition\n",
    "            \n",
    "    \n",
    "    def select_object_updater(self, object_class_name, \n",
    "                                    interpretation_situation = None,\n",
    "                                    interpretation_status = None,\n",
    "                                    random_choice = False,\n",
    "                                    debug= False,\n",
    "                                    **kargs):\n",
    "        \"\"\"Factory function that generates an updater for the given ontology class\n",
    "        \n",
    "        Parameters:\n",
    "        - object_class_name: the type of object to be created (typically, the ontology class name)\n",
    "        - interpretation_situation: a `InterpretationSituation` providing a context for the update\n",
    "        - interpretation_status: the status of the current interpretation process,  \n",
    "\n",
    "        # must provide anomaly\n",
    "\n",
    "        which might provide contextual information to decide which updater to generate\n",
    "        - random_choice: if False (default), the first available updater is selected, else it is picked randomly\n",
    "        - debug: if True, some debug information is sent, default False. \n",
    "        - kargs: keyword arguments passing available qualities and properties.\n",
    "        This will be used to check whether required information is available.\n",
    "        \n",
    "        Return:\n",
    "        - a function that can be called for creating a new instance of the given object.\n",
    "        \"\"\"\n",
    "        object_class_name = object_class_name if isinstance(object_class_name,str) else object_class_name.name\n",
    "        if debug:\n",
    "            print(\"Looking for a constructor for:\", object_class_name)\n",
    "            print(\" - registered constructors:\\n\", \"\\n\".join([str(updater) for updater in self.registered_updaters[object_class_name]]))\n",
    "        if object_class_name not in self.registered_updaters:\n",
    "            raise MalissiaBaseError(\"No available updater for {}.\".format(object_class_name))\n",
    "        candidate_updaters = [updater for updater in self.registered_updaters[object_class_name]\n",
    "                                  if self.updater_conditions[updater](\n",
    "                                        knowledge_framework = self,\n",
    "                                        interpretation_situation = interpretation_situation,\n",
    "                                        interpretation_status = interpretation_status,\n",
    "                                        **kargs)\n",
    "                                  ]\n",
    "        if debug:\n",
    "            print(\" - candidate constructors:\\n\", \"\\n\".join([str(updater) for updater in candidate_updaters]))\n",
    "        if len(candidate_updaters) == 0:\n",
    "            raise MalissiaBaseError(\"No available updater for {} in these conditions.\".format(object_class_name))\n",
    "        \n",
    "        selected_updater = random.choice(candidate_updaters) if random_choice else candidate_updaters[0]\n",
    "        if debug: print(\"Selected updater:\",str(selected_updater))\n",
    "        return selected_updater\n",
    "        \n",
    "\n",
    "\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constructors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def format_coord_dicts(coord_labels, coords):\n",
    "    label_keys = [\"coord{}_label\".format(i+1) for i in range(len(coord_labels))]\n",
    "    coord_keys = [\"coord{}\".format(i+1) for i in range(len(coords))]\n",
    "    coord_label_dict = {label_key:[coord_label_i] for label_key,coord_label_i in zip(label_keys, coord_labels)}\n",
    "    coord_dict = {coord_key:[float(coord_i)] for coord_key,coord_i in zip(coord_keys, coords)}\n",
    "    return coord_label_dict, coord_dict\n",
    "\n",
    "def constructor_point(knowledge_framework, coord_labels, coords, name= None):\n",
    "    coord_label_dict, coord_dict = format_coord_dicts(coord_labels=coord_labels, coords= coords)\n",
    "    point =knowledge_framework().Point(name= name, **coord_label_dict, **coord_dict)\n",
    "    \n",
    "    # it is represented by himself\n",
    "    point.has_Representation = [point]\n",
    "    point.has_Center = [point]\n",
    "    return point"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def constructor_vector(knowledge_framework, coord_labels, coords, name= None):\n",
    "    coord_label_dict, coord_dict = format_coord_dicts(coord_labels= coord_labels, coords= coords)\n",
    "    vector =  knowledge_framework().Vector(name= name, **coord_label_dict, **coord_dict)\n",
    "    \n",
    "    # it is represented by itmself\n",
    "    vector.has_Representation = [vector]\n",
    "    return vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Planar_Surface"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_coord_labels(plan):\n",
    "    node = plan.has_Node0[0]\n",
    "    return [node.coord1_label[0],node.coord2_label[0],node.coord3_label[0]]\n",
    "\n",
    "def get_nodes(plan):\n",
    "    return [plan.has_Node0[0], plan.has_Node1[0], plan.has_Node2[0], plan.has_Node3[0]]\n",
    "\n",
    "def get_coord(nodes):\n",
    "    \"\"\"returns the coordinates of a series of nodes as an array (node_index, coord_index)\"\"\"\n",
    "    return [[node_i.coord1[0],node_i.coord2[0],node_i.coord3[0]] for node_i in nodes]\n",
    "    \n",
    "def compute_center(nodes):\n",
    "    coords = get_coord(nodes= nodes)\n",
    "    center_coord = np.mean(coords,axis=0).tolist() \n",
    "    return center_coord\n",
    "\n",
    "def set_center(knowledge_framework, plan):\n",
    "    nodes = get_nodes(plan= plan)\n",
    "    center_coord = compute_center(nodes= nodes) \n",
    "    coord_labels = get_coord_labels(plan= plan)\n",
    "    \n",
    "    name = plan.name + \"_center\"\n",
    "    center = constructor_point(knowledge_framework= knowledge_framework, coord_labels= coord_labels, coords= center_coord, name= name)\n",
    "    plan.has_Center = [center]\n",
    "    return center\n",
    "\n",
    "def compute_principal_vectors_from_nodes(nodes):\n",
    "    coords = np.array(get_coord(nodes= nodes))\n",
    "    u = coords[1] - coords[0]\n",
    "    v = coords[3] - coords[0]\n",
    "    normal = np.cross(u,v)\n",
    "    normal = normal/np.linalg.norm(normal)\n",
    "    return u.tolist(), v.tolist(), normal.tolist()\n",
    "\n",
    "def compute_size_from_nodes(nodes):\n",
    "    coords = np.array(get_coord(nodes= nodes))\n",
    "    u = coords[1] - coords[0]\n",
    "    size = np.linalg.norm(u)\n",
    "    return float(size)\n",
    "\n",
    "def compute_dip_dir_from_normal(normal):\n",
    "    x,y,z = np.sign(normal[2]) * np.array(normal) / np.linalg.norm(normal)\n",
    "    if z == 1:\n",
    "        return 0.,0.\n",
    "    dip = np.rad2deg(np.arccos(z))\n",
    "    dip_dir = np.rad2deg(np.arctan2(x,y)) % 360\n",
    "    return float(np.round(dip, 3)), float(np.round(dip_dir, 3))\n",
    "\n",
    "def set_attitude(knowledge_framework, plan):\n",
    "    nodes = get_nodes(plan= plan)\n",
    "    coord_labels = get_coord_labels(plan= plan)\n",
    "    u, v, normal = compute_principal_vectors_from_nodes(nodes= nodes)\n",
    "    size = compute_size_from_nodes(nodes= nodes)\n",
    "    plan.size = [size]\n",
    "    \n",
    "    normal_name = plan.name + \"_normal\"\n",
    "    normal_entity = constructor_vector(knowledge_framework= knowledge_framework, coord_labels= coord_labels, coords= normal, name= normal_name)\n",
    "    plan.has_Normal = [normal_entity]\n",
    "    \n",
    "    dip, dip_dir = compute_dip_dir_from_normal(normal= normal)\n",
    "    plan.dip = [dip]\n",
    "    plan.dip_dir = [dip_dir]\n",
    "    return dip, dip_dir, normal, size\n",
    "\n",
    "def set_nodes(plan, nodes):\n",
    "    if(len(nodes) != 4): raise MalissiaBaseError(\"Please give 4 nodes in, {} were given.\".format(len(nodes)))\n",
    "    plan.has_Node0 = [nodes[0]]\n",
    "    plan.has_Node1 = [nodes[1]]\n",
    "    plan.has_Node2 = [nodes[2]]\n",
    "    plan.has_Node3 = [nodes[3]]\n",
    "    plan.has_Representation = nodes\n",
    "\n",
    "def set_nodes_succession(node0, node1, node2, node3):\n",
    "\n",
    "    node0.has_Next_Nodes.append([node1, node2, node3])\n",
    "    node0.has_Previous_Nodes.append([node3, node2, node1])\n",
    "\n",
    "    node1.has_Next_Nodes.append([node2, node3, node0])\n",
    "    node1.has_Previous_Nodes.append([node0, node3, node2])\n",
    "\n",
    "    node2.has_Next_Nodes.append([node3, node0, node1])\n",
    "    node2.has_Previous_Nodes.append([node1, node0, node3])\n",
    "\n",
    "    node3.has_Next_Nodes.append([node0, node1, node2])\n",
    "    node3.has_Previous_Nodes.append([node2, node1, node0])\n",
    "    \n",
    "def create_planar_surface(knowledge_framework, nodes, name= None):\n",
    "    plan = knowledge_framework().Planar_Surface(name= name)\n",
    "    set_nodes(plan,nodes)\n",
    "    return plan\n",
    "\n",
    "def create_nodes_from_coords(knowledge_framework, coords, coord_labels, name= None):\n",
    "    names = [None if name is None else name + \"_N\" + str(i) for i in range(len(coords))]\n",
    "    nodes = [\n",
    "        constructor_point(knowledge_framework= knowledge_framework, coord_labels= coord_labels, coords= coord_i, name= name_i)\n",
    "        for coord_i, name_i in zip(coords,names)\n",
    "    ]\n",
    "    return nodes\n",
    "\n",
    "def compute_normal_from_dip_dir(dip, dip_dir, polarity= 1):\n",
    "    dip_rad = np.deg2rad(dip)\n",
    "    dip_dir_rad = np.deg2rad(dip_dir)\n",
    "    z = np.cos(dip_rad)\n",
    "    h = np.sin(dip_rad)\n",
    "    y = h * np.cos(dip_dir_rad)\n",
    "    x = h * np.sin(dip_dir_rad)\n",
    "    normal = polarity * np.array([x,y,z])\n",
    "    return normal.tolist()\n",
    "\n",
    "def compute_principal_vectors_from_dip_dir(dip, dip_dir, polarity= 1, as_array= False):\n",
    "    \"\"\"returns normal, dip_vector, azimuth_vector\"\"\"\n",
    "    dip_rad = np.deg2rad(dip)\n",
    "    dip_dir_rad = np.deg2rad(dip_dir)\n",
    "    nz =  np.cos(dip_rad)\n",
    "    h = np.sin(dip_rad)\n",
    "    hy = np.cos(dip_dir_rad)\n",
    "    hx = np.sin(dip_dir_rad)\n",
    "    ny = h * hy\n",
    "    nx = h * hx\n",
    "    normal = polarity * np.array([nx,ny,nz])\n",
    "    \n",
    "    uz = -h\n",
    "    ux = nz * hx\n",
    "    uy = nz * hy\n",
    "    dip_vector = np.array([ux,uy,uz])\n",
    "    \n",
    "    az_vector = np.cross(normal, dip_vector)\n",
    "    \n",
    "    if as_array:\n",
    "        return normal, dip_vector, az_vector\n",
    "    else:\n",
    "        return normal.tolist(), dip_vector.tolist(), az_vector.tolist()\n",
    "\n",
    "def compute_coords(center, dip_vector, az_vector, size):\n",
    "    center     = np.array(center)\n",
    "    dip_vector = np.array(dip_vector)\n",
    "    az_vector  = np.array(az_vector)\n",
    "    coords = np.array([\n",
    "        center - size/2 * dip_vector - size/2 * az_vector,\n",
    "        center + size/2 * dip_vector - size/2 * az_vector,\n",
    "        center + size/2 * dip_vector + size/2 * az_vector,\n",
    "        center - size/2 * dip_vector + size/2 * az_vector\n",
    "    ])\n",
    "    return coords.tolist()\n",
    "\n",
    "def polarity_to_bool(polarity):\n",
    "    return bool(polarity > 0)\n",
    "\n",
    "def polarity_to_float(polarity:bool):\n",
    "    return 1 if polarity else -1\n",
    "\n",
    "def constructor_planar_surface_from_nodes(knowledge_framework, nodes, name= None):\n",
    "    plan = create_planar_surface(knowledge_framework= knowledge_framework, nodes= nodes, name= name)\n",
    "    center = set_center(knowledge_framework= knowledge_framework, plan= plan)\n",
    "    dip, dip_dir, normal, size = set_attitude(knowledge_framework= knowledge_framework, plan= plan)\n",
    "    return plan\n",
    "\n",
    "def constructor_planar_surface_from_coords(knowledge_framework, coords, coord_labels, name= None):\n",
    "    nodes = create_nodes_from_coords(knowledge_framework= knowledge_framework, coords= coords, coord_labels= coord_labels, name= name)\n",
    "    return constructor_planar_surface_from_nodes(knowledge_framework= knowledge_framework, nodes= nodes, name= name)\n",
    "\n",
    "def constructor_planar_surface_from_center_attitude(knowledge_framework, coord_labels, \n",
    "                                                    center, dip, dip_dir, size= None,\n",
    "                                                     polarity= True, name= None):\n",
    "    normal, dip_vector, az_vector = compute_principal_vectors_from_dip_dir(dip= dip, dip_dir= dip_dir, polarity= polarity)\n",
    "    coords = compute_coords(center= center, dip_vector= dip_vector, az_vector= az_vector, size= size)\n",
    "    nodes = create_nodes_from_coords(knowledge_framework= knowledge_framework, coords= coords, coord_labels= coord_labels)\n",
    "    plan = create_planar_surface(knowledge_framework= knowledge_framework, nodes= nodes, name= name)\n",
    "    \n",
    "    plan.dip = [float(dip)]\n",
    "    plan.dip_dir = [float(dip_dir)]\n",
    "    plan.polarity = [polarity_to_bool(polarity)]\n",
    "    plan.size = [float(size)]\n",
    "    \n",
    "    center_name = plan.name + \"_center\"\n",
    "    center_entity = constructor_point(knowledge_framework= knowledge_framework, coord_labels= coord_labels, coords= center, name= center_name)\n",
    "    plan.has_Center= [center_entity]\n",
    "    \n",
    "    normal_name = plan.name + \"_normal\"\n",
    "    normal_entity = constructor_vector(knowledge_framework= knowledge_framework, coord_labels= coord_labels, coords= normal, name= normal_name)\n",
    "    plan.has_Normal = [normal_entity]\n",
    "    return plan\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Planar Surface anomalies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# consistency between nodes order and normal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Observations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def conditions_for_constructor_observation(knowledge_framework:GeologicalKnowledgeFramework, **kargs):\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        print(\"Wrong condition for observation constructor: knowledge framework\")\n",
    "        return False\n",
    "    if (\"dataset\" not in kargs) or (kargs[\"dataset\"] is None):\n",
    "        print(\"Wrong condition for observation constructor: dataset\")\n",
    "        return False\n",
    "    dataset = kargs[\"dataset\"]\n",
    "    if (dataset.physical_space is None):\n",
    "        print(\"Wrong condition for observation constructor: physical space\")\n",
    "        return False\n",
    "    if not np.all([coord in kargs for coord in dataset.physical_space.coordinate_labels]):\n",
    "        print(\"Wrong condition for observation constructor: coord\")\n",
    "        return False\n",
    "    return True\n",
    "    \n",
    "def constructor_observation(knowledge_framework= None, name: str= None,\n",
    "                            dataset= None, physical_space= None, coord_labels= None,\n",
    "                            **kargs):\n",
    "    \"\"\"Constructor of observations\n",
    "    \n",
    "    Parameters:\n",
    "    - knowledge_framework: defining the existing objects, if None it is inferred from the dataset if given\n",
    "    - name: the name of the observation (similar to an observation id). If None a default one is given.\n",
    "    - dataset: (optional) the dataset to which this observation belongs.\n",
    "    If given, the physical space is taken from there unless it is specified\n",
    "    - physical_space: (optional) the physical space in which this observation is defined.\n",
    "    If not given, it is taken from the dataset, or if not dataset is provided, the coordinate_labels must be given\n",
    "    - coord_labels: (optional) a list of coordinate names, required only if no physical space is provided\n",
    "    - kargs: keyword arguments, containing:\n",
    "        - spatial coordinates with names matching the dataset.physical_space coordinate labels\n",
    "        - any other quality that should be associated with the observation\n",
    "         * size: should be set, this is the size of the area represented by this observation\n",
    "         * dip and dip_dir: optional, make it an orientation observation, should both be set together\n",
    "         * polarity: optional, only used if dip an ddip_dir are set, boolean indicating the polarity of the observed feature.\n",
    "         True means up (or towards the dip_dir if vertical), False is the opposite\n",
    "         * occurrence: optional make it an occurrence observation, True (thing has been observed)\n",
    "         or False (it has been observed that the thing is not here). Note: if the observation is not made on the\n",
    "         occurrence of the observed object, don't set this property, do not set it to False.\n",
    "         * observed_object: the name of the observed object\n",
    "        - qualities whose values is None are not set\n",
    "        - Note that the dataset.physical_space will be asked to filter the provided information\n",
    "        \n",
    "    Return:\n",
    "    - the created observation\n",
    "    \"\"\"\n",
    "    \n",
    "    if knowledge_framework is None:\n",
    "        if dataset is not None:\n",
    "            knowledge_framework = dataset.knowledge_framework\n",
    "        else:\n",
    "            raise MalissiaBaseError(\"provide at least a knowledge framework or a dataset\")\n",
    "    \n",
    "    # create Observation\n",
    "    obs = knowledge_framework().PointBased_Observation(name= name)\n",
    "\n",
    "    # create a point as geometrical support\n",
    "    physical_space = physical_space if physical_space is not None else \\\n",
    "        (dataset.physical_space if dataset is not None else None)\n",
    "    coord_labels = physical_space.coordinate_labels if physical_space is not None else coord_labels\n",
    "    if coord_labels is None:\n",
    "        raise MalissiaBaseError(\"coordinate labels must be specified somehow.\")\n",
    "    coords = [kargs[i] for i in coord_labels]\n",
    "    point = constructor_point(knowledge_framework= knowledge_framework,\n",
    "                              coord_labels= coord_labels, coords= coords,\n",
    "                              name= obs.name + \"_point\")\n",
    "    obs.has_Center = [point]\n",
    "    obs.has_Representation = [point]\n",
    "    \n",
    "    # add size\n",
    "    if \"size\" in kargs:\n",
    "        obs.size = [kargs[\"size\"]]\n",
    "    elif physical_space is not None:\n",
    "        domain_size = float(max(physical_space.get_size()))\n",
    "        obs.size = [domain_size / 10]\n",
    "    else:\n",
    "        obs.size = [1]\n",
    "    \n",
    "    # add observed qualities\n",
    "    if \"occurrence\" in kargs:\n",
    "        obs.occurrence = [kargs[\"occurrence\"]]\n",
    "    if (\"dip\" in kargs) and (\"dip_dir\" in kargs):\n",
    "        obs.dip     = [kargs[\"dip\"]]\n",
    "        obs.dip_dir = [kargs[\"dip_dir\"]]\n",
    "        if \"polarity\" in kargs:\n",
    "            obs.polarity = [polarity_to_bool(kargs[\"polarity\"])]\n",
    "        else:\n",
    "            obs.polarity = [True]\n",
    "            \n",
    "    # find or create observed object\n",
    "    if \"observed_object\" in kargs and kargs[\"observed_object\"] is not None:\n",
    "        observed = knowledge_framework.search(type=knowledge_framework().Geological_Concept, name= kargs[\"observed_object\"])\n",
    "        if len(observed) == 0:\n",
    "            new_observed = knowledge_framework().Stratigraphic_Surface(name=kargs[\"observed_object\"])\n",
    "            obs.is_Observation_Of = [new_observed]\n",
    "        elif len(observed) == 1:\n",
    "            obs.is_Observation_Of = observed\n",
    "        else:\n",
    "            raise MalissiaBaseError(\"Warning: observed object ({}) could correspond to more than one among: {}\".format(\n",
    "                kargs[\"observed_object\"],\n",
    "                \", \".join([str(observed_i) for observed_i in observed])\n",
    "                ))\n",
    "    \n",
    "    obs.is_Explained_By = []\n",
    "    \n",
    "    return obs\n",
    "\n",
    "if \"Observation\" in GeologicalKnowledgeFramework.registered_constructors:\n",
    "    del GeologicalKnowledgeFramework.registered_constructors[\"Observation\"]\n",
    "GeologicalKnowledgeFramework.register_constructor(\"Observation\", \n",
    "                                                  constructor= constructor_observation,\n",
    "                                                  condition= conditions_for_constructor_observation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Observation anomalies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# internal consistency anomaly\n",
    "# eg. dip, dip_dir out of range\n",
    "# must have at least (dip and dip_dir) or occurrence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Situation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class InterpretationSituation(object):\n",
    "    \"\"\"Defines a situation of interpretation.\n",
    "    \n",
    "    A situation is gathering:\n",
    "    - self.features: features to be explained\n",
    "    - self.context: an interpretation context, ie. elements to be considered during the interpretation\n",
    "    - self.process: the interpretation process in which this situation arises\n",
    "    - self.candidate_explanation_class: the class selected as possible explanation\n",
    "    - self.explaining_object: an instance of the self.candidate_explanation_class, either newly created or reused\n",
    "    - self.existing_explaining_object: a boolean to tell if the self.explaining_object is reused (True) or new (False)\n",
    "    - self.anomalies: the detected anomalies regarding this situation\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, features, process= None, context = None, knowledge_framework= None) -> None:\n",
    "        \"\"\"Initialises the situation\n",
    "        \n",
    "        Parameters:\n",
    "         - self.features: features to be explained\n",
    "         - self.context: an interpretation context, ie. elements to be considered during the interpretation\n",
    "         - self.process: the interpretation process in which this situation arises\n",
    "         - self.candidate_explanation_class: the class selected as possible explanation\n",
    "         - self.explaining_object: an instance of the self.candidate_explanation_class, either newly created or reused\n",
    "         - self.existing_explaining_object: a boolean to tell if the self.explaining_object is reused (True) or new (False)\n",
    "         - self.anomalies: the detected anomalies regarding this situation\n",
    "         \"\"\"\n",
    "        self.features = np.array(features).ravel() if features is not None else np.array([])\n",
    "        self.context = np.array(context).ravel() if context is not None else np.array([])\n",
    "        self.candidate_explanation_class = None\n",
    "        self.explaining_object = None\n",
    "        self.existing_explaining_object = None\n",
    "        self.anomalies = []\n",
    "        self.process = process\n",
    "        self.knowledge_framework = knowledge_framework if knowledge_framework is not None else \\\n",
    "            (process.knowledge_framework if process is not None else None)\n",
    "    \n",
    "    def __str__(self):\n",
    "        out = []\n",
    "        #out += [\"Process: {}\".format(self.process)]\n",
    "        #out += [\"Knowledge Framework: {}\".format(self.knowledge_framework)]\n",
    "        out += [\"Features: {}\".format(\"None\" if (self.features is None) or (len(self.features) == 0)else\", \".join([str(i) for i in self.features]))]\n",
    "        out += [\"Context: {}\".format(\"None\" if (self.context is None) or (len(self.context) == 0) else \", \".join([str(i) for i in self.context]))]\n",
    "        out += [\"Candidate explaining class: \" + str(self.candidate_explanation_class)]\n",
    "        out += [\"Explaining Object: {}\".format(None if self.explaining_object is None else str(self.explaining_object))\\\n",
    "            +(\"(reused)\" if self.existing_explaining_object else \"\")\n",
    "            ]\n",
    "        out += [\"Anomalies: {}\".format(\"None\" if (self.anomalies is None) or (len(self.anomalies) == 0)else\", \".join([str(i) for i in self.anomalies]))]\n",
    "        return \"\\n\".join(out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Stratigraphy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def conditions_for_constructor_surface_part_from_interpretation(\n",
    "                                            knowledge_framework:GeologicalKnowledgeFramework,\n",
    "                                            interpretation_situation:InterpretationSituation, **kargs):\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        print(\"Wrong condition for Surface Part constructor: knowledge framework\")\n",
    "        return False\n",
    "    if (interpretation_situation is None):\n",
    "        print(\"Wrong condition for Surface Part constructor: interpretation situation\")\n",
    "        return False\n",
    "    if  (interpretation_situation.process is None) or (interpretation_situation.process.representation_space is None):\n",
    "        print(\"Wrong condition for Surface Part constructor: physical space\")\n",
    "        return False\n",
    "    if  (interpretation_situation.features is None) or (len(interpretation_situation.features) == 0):\n",
    "        print(\"Wrong condition for Surface Part constructor: features\")\n",
    "        return False\n",
    "    \n",
    "    constructed_class = knowledge_framework().Stratigraphic_Part\n",
    "    explainable_features = knowledge_framework.filter_explainable_features(constructed_class, interpretation_situation.features)\n",
    "    if len(explainable_features) == 0:\n",
    "        print(\"Wrong condition for Surface Part constructor: No explainable feature in the situation with this interpretation. To be implemented.\")\n",
    "        return False\n",
    "    # in any other cases\n",
    "    return True\n",
    "\n",
    "def conditions_for_constructor_surface_part_from_interpretation_of_parts(\n",
    "                                            knowledge_framework:GeologicalKnowledgeFramework,\n",
    "                                            interpretation_situation:InterpretationSituation, **kargs):\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        print(\"Wrong condition for Surface Part constructor: knowledge framework\")\n",
    "        return False\n",
    "    if (interpretation_situation is None):\n",
    "        print(\"Wrong condition for Surface Part constructor: interpretation situation\")\n",
    "        return False\n",
    "    if  (interpretation_situation.process is None) or (interpretation_situation.process.representation_space is None):\n",
    "        print(\"Wrong condition for Surface Part constructor: physical space\")\n",
    "        return False\n",
    "    if  (interpretation_situation.features is None) or (len(interpretation_situation.features) == 0):\n",
    "        print(\"Wrong condition for Surface Part constructor: features\")\n",
    "        return False\n",
    "   \n",
    "    explained_class = knowledge_framework().Stratigraphic_Part\n",
    "    explainable_features_strati = knowledge_framework.filter_explainable_features_by_type( interpretation_situation.features, \n",
    "                                                                                   type_of_feature = explained_class)\n",
    "    \n",
    "    if len(explainable_features_strati) < 2:\n",
    "        return False\n",
    "    return True\n",
    "    \n",
    "def get_physical_space_in_constructor(interpretation_situation, physical_space= None, **kargs):\n",
    "    \"\"\"Gets a physical representation space from an interpreted situation of context\"\"\"\n",
    "    if physical_space is not None:\n",
    "        return physical_space\n",
    "    if interpretation_situation is not None \\\n",
    "    and interpretation_situation.process is not None \\\n",
    "    and interpretation_situation.process.representation_space is not None:\n",
    "        return interpretation_situation.process.representation_space\n",
    "    else:\n",
    "        raise MalissiaBaseError(\"Wrong conditions for physical space definition.\")\n",
    "\n",
    "def get_feature_locations(features, physical_space):\n",
    "    \"\"\"Returns the coordinates of the feature representations\n",
    "    \n",
    "    Parameters:\n",
    "    - features: a list of features, must have a representation\n",
    "    - physical_space: either a physical space that will be used to recover there geometry or\n",
    "    \"original\" keyword, meaning the coordinates must be recovered from the original coordinates directly.\n",
    "    NB: this will assume all the features have the same coordinates and labels.\"\"\"\n",
    "    if physical_space == \"original\":\n",
    "        reps = [feature_i.has_Representation for feature_i in features]\n",
    "        filtered_reps = [rep_i[0] for rep_i in reps if (rep_i is not None) and (len(rep_i)>0)]\n",
    "        coords = [[rep_i.coord1[0], rep_i.coord2[0], rep_i.coord3[0]] for rep_i in filtered_reps]\n",
    "        return np.array(coords)\n",
    "    else:\n",
    "        return np.array([physical_space.get_object_coordinates(feature_i) for feature_i in features])\n",
    "\n",
    "def location_constructor(features, physical_space, method= \"average\", return_as_dict= False, **kargs):\n",
    "    \"\"\"Estimated a location from a given situation and or space\n",
    "    \n",
    "    Parameters:\n",
    "    - features: a list of features that can inform the location, if empty the location is set from the physical_space\n",
    "    - physical_space: the space in whichthe new location is to be defined\n",
    "    - method: determines how th e new location should be estimated (pick, random, average)\n",
    "    Returns:\n",
    "    - a dict matching each coordinate label with its coordinate value\n",
    "    \"\"\" \n",
    "    if physical_space is None: raise MalissiaBaseError(\"a physical space is required, use get_physical_space_in_constructor\")\n",
    "    if len(features) == 0:\n",
    "        # set from the physical space\n",
    "        if method == \"average\":\n",
    "            location = physical_space.get_center()\n",
    "        else:\n",
    "            location = physical_space.generate_random_location()\n",
    "    else:\n",
    "        coords = get_feature_locations(features, physical_space)\n",
    "        if method == \"average\":\n",
    "            # take the average position as new position\n",
    "            location = np.mean(coords, axis= 0)\n",
    "        elif method == \"pick\":\n",
    "            # pick a random location from the dataset\n",
    "            location = np.random.default_rng().choice(coords)\n",
    "        elif method == \"random\":\n",
    "            # generate a random location in the space covered by the data points\n",
    "            mean = np.mean(coords, axis= 0)\n",
    "            cov = np.cov(coords, rowvar=False)\n",
    "            location = np.random.default_rng().multivariate_normal(mean, cov)\n",
    "        return physical_space.coordinates_to_dict(location) if return_as_dict else location.tolist()\n",
    "        \n",
    "\n",
    "def format_attitude_qualities(dip, dip_dir, polarity= True, size= 1):\n",
    "    return {\"dip\":float(dip),\"dip_dir\":float(dip_dir), \"polarity\": polarity_to_bool(polarity), \"size\": float(size)}\n",
    "\n",
    "def attitude_constructor_from_space(physical_space):\n",
    "    \"\"\"Estimated attitude from a list of points\"\"\"\n",
    "    dip = physical_space.generate_random_dip()\n",
    "    dip_dir = physical_space.generate_random_dip_dir()\n",
    "    polarity = physical_space.generate_random_polarity()\n",
    "    size = physical_space.generate_random_size()\n",
    "    return format_attitude_qualities(dip= dip, dip_dir= dip_dir, polarity= polarity, size= size)\n",
    "    \n",
    "def compute_extremities(features, physical_space):\n",
    "    principal_vectors = [compute_principal_vectors_from_dip_dir(\n",
    "        dip= feature_i.dip[0],\n",
    "        dip_dir= feature_i.dip_dir[0],\n",
    "        polarity= polarity_to_float(feature_i.polarity[0]),\n",
    "        as_array=True\n",
    "    )\n",
    "     for feature_i in features]\n",
    "    centers = get_feature_locations(features, physical_space)\n",
    "    sizes = [feature_i.size[0] for feature_i in features]\n",
    "    coords = [[c_i - 0.5*s_i * vec_i[1] - 0.5*s_i * vec_i[2],\n",
    "              c_i + 0.5*s_i * vec_i[1] - 0.5*s_i * vec_i[2],\n",
    "              c_i + 0.5*s_i * vec_i[1] + 0.5*s_i * vec_i[2],\n",
    "              c_i - 0.5*s_i * vec_i[1] + 0.5*s_i * vec_i[2],\n",
    "              ]\n",
    "             for vec_i, c_i, s_i in zip(principal_vectors,centers,sizes)]\n",
    "    return np.array(coords).reshape((-1,3))\n",
    "\n",
    "def average_attitude_feature_from_extremities(features, physical_space):\n",
    "    \"\"\"Estimates attitude by associating extremities to each feature and computing a medium plan\"\"\"\n",
    "    coords = compute_extremities(features, physical_space).reshape((-1,3))\n",
    "    attitude = attitude_constructor_from_points(coords, physical_space, method= \"average\")\n",
    "    attitude[\"polarity\"] = True # todo: take account of polarity\n",
    "    return attitude\n",
    "    \n",
    "def average_attitude_feature_from_vectors(features, physical_space):\n",
    "    \"\"\"Estimate the attitude by taking the average normal vector\"\"\"\n",
    "    vectors = [compute_normal_from_dip_dir(\n",
    "                dip= feature_i.dip[0],\n",
    "                dip_dir= feature_i.dip_dir[0],\n",
    "                polarity= polarity_to_float(feature_i.polarity[0])\n",
    "            ) for feature_i in features]\n",
    "    normal = physical_space.compute_average_vector(vectors)\n",
    "    dip, dip_dir, polarity = physical_space.compute_dip_dir_from_normal(normal)\n",
    "    size = np.mean([feature_i.size[0] for feature_i in features])\n",
    "    polarity = physical_space.generate_random_polarity()\n",
    "    \n",
    "    return format_attitude_qualities(\n",
    "        dip= dip, dip_dir= dip_dir,\n",
    "        polarity= polarity, size= size\n",
    "    )\n",
    "        \n",
    "def attitude_constructor_from_attitude_features(features, physical_space, method= \"average\"):\n",
    "    \"\"\"Estimated attitude from a list of features having attitudes\"\"\"\n",
    "    if method == \"pick\":\n",
    "        picked_feature = np.random.default_rng().choice(features)\n",
    "        return format_attitude_qualities(\n",
    "            dip= picked_feature.dip[0], dip_dir= picked_feature.dip_dir[0],\n",
    "            polarity= picked_feature.polarity[0], size= picked_feature.size[0]\n",
    "        )\n",
    "    elif method == \"average\":\n",
    "        return average_attitude_feature_from_extremities(features, physical_space)\n",
    "    elif method == \"average_vector\":\n",
    "        return average_attitude_feature_from_vectors(features, physical_space)\n",
    "    else:\n",
    "        raise MalissiaBaseError(\"unimplemented method: \"+method)\n",
    "    \n",
    "\n",
    "def attitude_constructor_from_points(points, physical_space, method= \"average\"):\n",
    "    \"\"\"Estimated attitude from a list of points\"\"\"\n",
    "    if len(points) < 2:\n",
    "        raise MalissiaBaseError(\"not enough points to estimate attitude\")\n",
    "    if len(points) == 2:\n",
    "        line = physical_space.compute_line_attitude_from_two_points(*points)\n",
    "        if method == \"average\":\n",
    "            plane = line\n",
    "        else:\n",
    "            raise MalissiaBaseError(\"method not implemented yet: \" + method)\n",
    "    else:\n",
    "        if method == \"average\":\n",
    "            plane = physical_space.compute_attitude_from_points(points)\n",
    "        else:\n",
    "            raise MalissiaBaseError(\"method not implemented yet: \" + method)\n",
    "        \n",
    "    polarity = physical_space.generate_random_polarity()\n",
    "    return format_attitude_qualities(dip= plane[\"dip\"], dip_dir= plane[\"dip_dir\"], size= plane[\"size\"], polarity= polarity)\n",
    "\n",
    "def attitude_constructor_from_single_feature(feature, physical_space, knowledge_framework= None):\n",
    "    # if it has dip and dip_dir -> use it\n",
    "    dip = feature.dip[0] if knowledge_framework.has_quality(feature, \"dip\") else physical_space.generate_random_dip()\n",
    "    dip_dir = feature.dip_dir[0] if knowledge_framework.has_quality(feature, \"dip_dir\") else physical_space.generate_random_dip_dir()\n",
    "    size = feature.size[0] if knowledge_framework.has_quality(feature, \"size\") else physical_space.generate_random_size(min_perc= 0.05, max_perc= 0.25)\n",
    "    return format_attitude_qualities(dip= dip, dip_dir= dip_dir, size=size)\n",
    "\n",
    "def get_coords_from_planar_surfaces(features, physical_space, knowledge_framework):\n",
    "    features = [feature_i for feature_i in features\n",
    "                if (knowledge_framework.isinstance(feature_i, knowledge_framework().Planar_Surface))\n",
    "                or (knowledge_framework.isinstance(feature_i, knowledge_framework().Stratigraphic_Part))]\n",
    "    coords = [physical_space.get_object_coordinates(feature_i, kind=\"nodes\") for feature_i in features]\n",
    "    return coords\n",
    "    \n",
    "def get_coords_from_occurrence_observations(features, physical_space, knowledge_framework):\n",
    "    features = [feature_i for feature_i in features\n",
    "                if (knowledge_framework.isinstance(feature_i, knowledge_framework().Point))\n",
    "                or ((knowledge_framework.isinstance(feature_i, knowledge_framework().PointBased_Observation))\n",
    "                    and ((feature_i.dip is None) or (len(feature_i.dip) == 0)))]\n",
    "    coords = [physical_space.get_object_coordinates(feature_i, kind=\"center\") for feature_i in features]\n",
    "    return coords\n",
    "    \n",
    "def get_coords_from_orientation_observations(features, physical_space, knowledge_framework):\n",
    "    features = [feature_i for feature_i in features\n",
    "                if (knowledge_framework.isinstance(feature_i, knowledge_framework().PointBased_Observation))\n",
    "                and ((feature_i.dip is not None) and (len(feature_i.dip) > 0))]\n",
    "    coords = compute_extremities(features, physical_space)\n",
    "    return coords.tolist()\n",
    "    \n",
    "def attitude_constructor(features, physical_space, knowledge_framework= None, method= \"average\",\n",
    "                         regression=\"orthogonal\", extension_factor= 0.05, **kargs):\n",
    "    \"\"\"Estimated the attitude of a feature from a given situation and or space\n",
    "    \n",
    "    Parameters:\n",
    "    - features: a list of features that can inform the location\n",
    "    - physical_space: the space in which the new location is to be defined\n",
    "    - method: determines how the new attitude should be estimated (pick, random, average)\n",
    "    - extension_factor: float, default 0.05, amount of extra size on both sides \n",
    "    for the inferred length to go slightly beyond the data points\n",
    "    \"\"\" \n",
    "    if physical_space is None: raise MalissiaBaseError(\"a physical space is required, use get_physical_space_in_constructor\")\n",
    "    knowledge_framework = GeologicalKnowledgeManager().get_knowledge_framework() if knowledge_framework is None else knowledge_framework\n",
    "   \n",
    "    if len(features) == 0:\n",
    "        return attitude_constructor_from_space(physical_space)\n",
    "    elif len(features) == 1:\n",
    "        return attitude_constructor_from_single_feature(features[0], \n",
    "                                                        physical_space= physical_space, \n",
    "                                                        knowledge_framework= knowledge_framework)\n",
    "    else:\n",
    "        # filtering features        \n",
    "        # planar surfaces have nodes -> use the nodes\n",
    "        coords = get_coords_from_planar_surfaces(features, physical_space, knowledge_framework)\n",
    "        if isinstance(coords, list):\n",
    "            coords = [item for sublist in coords for item in sublist]\n",
    "        if isinstance(coords, np.ndarray):\n",
    "            coords = coords.ravel()\n",
    "        # Observation of orientation have dip_dir dip size -> compute and use extremities\n",
    "        coords +=  get_coords_from_orientation_observations(features, physical_space, knowledge_framework)\n",
    "        \n",
    "        # Observations with orientation -> use their center 4 times (to equilibrate with the others)\n",
    "        coords += 4 * get_coords_from_occurrence_observations(features, physical_space, knowledge_framework)\n",
    "\n",
    "        coords = [np.array(co) for co in coords]\n",
    "        coords = np.array(coords)\n",
    "        \n",
    "        plane = {}\n",
    "        plane[\"center\"] = np.mean(coords, axis=0)\n",
    "        dx = coords[:,0] - plane[\"center\"][0]\n",
    "        dz = coords[:,2] - plane[\"center\"][2]\n",
    "        if np.all(dx == 0):\n",
    "            plane[\"dip\"] = 90.\n",
    "            plane[\"dip_dir\"] = 90.\n",
    "            plane[\"polarity\"] = 1\n",
    "            plane[\"size\"] = 2*np.max(np.abs(dz))\n",
    "        else:\n",
    "            cov =  np.dot(dx,dz)\n",
    "            vx = np.dot(dx,dx)\n",
    "            vz = np.dot(dz,dz)\n",
    "            if regression == \"orthogonal\":# orthogonal regression\n",
    "                if cov == 0.:\n",
    "                    a = 0\n",
    "                else:\n",
    "                    C = 0.5 * (vx - vz) / cov\n",
    "                    a = -C + np.sign(cov) * np.sqrt(C*C + 1)\n",
    "            elif regression == \"z\":\n",
    "                a = cov / vz\n",
    "            else:\n",
    "                a = cov / vx\n",
    "            \n",
    "            plane[\"dip\"] = np.rad2deg(np.arctan(np.abs(a)))\n",
    "            plane[\"dip_dir\"] = 270. if np.sign(a) >= 0 else 90.\n",
    "            plane[\"polarity\"] = 1\n",
    "            \n",
    "            dip_vector = np.array([np.cos(a), np.sin(a)])\n",
    "            p_dxdz = np.array([dx,dz]).T\n",
    "            plane[\"size\"] = 2 * (1 + extension_factor) * np.max(np.abs(np.dot(p_dxdz, dip_vector)))\n",
    "        return format_attitude_qualities(dip= plane[\"dip\"], dip_dir= plane[\"dip_dir\"], \n",
    "                                         size= plane[\"size\"], polarity= plane[\"polarity\"])\n",
    "    \n",
    "        # is_instance_of_point = [knowledge_framework.has_point_representation(feature_i) for feature_i in features]\n",
    "        # point_features = features[is_instance_of_point]\n",
    "        # points = [physical_space.get_object_coordinates(point_feature_i) for point_feature_i in point_features]\n",
    "        \n",
    "        # is_attitude_instance = [knowledge_framework.has_qualities(feature_i,[\"dip\",\"dip_dir\"]) for feature_i in features]\n",
    "        # attitude_features = features[is_attitude_instance]\n",
    "        \n",
    "        # # if only points then create from them\n",
    "        # if np.all(is_attitude_instance):\n",
    "        #     return attitude_constructor_from_attitude_features(attitude_features, physical_space= physical_space, method= method)\n",
    "        # elif np.all(is_instance_of_point):\n",
    "        #     return attitude_constructor_from_points(points, physical_space= physical_space, method= method)\n",
    "        # else:\n",
    "        #     return attitude_constructor_from_points_and_attitude_features(points, attitude_features, physical_space= physical_space, method= method)    \n",
    "    \n",
    "def create_surface_part(knowledge_framework, surface_representation, explained_features = None,  name=None, **kargs):\n",
    "\n",
    "    # Instanciate a Stratigraphic_Part pointing to the planarsurface representation\n",
    "    class_type = knowledge_framework().Stratigraphic_Part\n",
    "    surface_part = knowledge_framework.create_instance(class_type, \n",
    "                                                       name, has_Representation= surface_representation, **kargs)\n",
    "    \n",
    "    # explanation relationship\n",
    "    if explained_features is not None : \n",
    "        surface_part.explain = explained_features\n",
    "    surface_part.is_Explained_By = []\n",
    "    return surface_part\n",
    "     \n",
    "def constructor_surface_part_from_interpretation( interpretation_situation, knowledge_framework= None,\n",
    "                                                 physical_space= None, name= None, **kargs):\n",
    "    \"\"\"Constructor of observations\n",
    "    \n",
    "    Parameters:\n",
    "    - knowledge_framework: the knowledge framework in which this object must be created\n",
    "    - interpretation_situation: the interpretation situation selected in the given state of interpretation process\n",
    "    - physical_space: the physical representation space where the surface is to be defined, if None the one from the interpretation_situation.process is used\n",
    "        \n",
    "    Return:\n",
    "    - the created Surface Part\n",
    "    \"\"\"\n",
    "    knowledge_framework = knowledge_framework if knowledge_framework is not None else interpretation_situation.knowledge_framework\n",
    "    physical_space = get_physical_space_in_constructor(interpretation_situation, physical_space, **kargs)\n",
    "    \n",
    "    constructed_class = knowledge_framework().Stratigraphic_Part\n",
    "    explainable_features = knowledge_framework.filter_explainable_features(constructed_class, interpretation_situation.features)\n",
    "    if len(explainable_features) == 0:\n",
    "        print(\"Warning: No explainable feature in the situation with this interpretation. Surface part can not be built. To be implemented.\")\n",
    "        return None\n",
    "    \n",
    "\n",
    "    #estimate location\n",
    "    location_qualities = location_constructor(features= explainable_features, physical_space= physical_space, method= \"average\", **kargs)\n",
    "    \n",
    "    # estimate attitude\n",
    "    attitude_qualities = attitude_constructor(features= explainable_features, physical_space= physical_space,\n",
    "                                            knowledge_framework= knowledge_framework, method= \"average\", **kargs)\n",
    "    # Instanciate a PlanarSurface\n",
    "    name_rep = None if name is None else name+\"_rep\"\n",
    "    surface_representation = constructor_planar_surface_from_center_attitude(\n",
    "                                    knowledge_framework= knowledge_framework,\n",
    "                                    coord_labels= physical_space.coordinate_labels,\n",
    "                                    center= location_qualities,\n",
    "                                    dip= attitude_qualities[\"dip\"],\n",
    "                                    dip_dir= attitude_qualities[\"dip_dir\"],\n",
    "                                    polarity= attitude_qualities[\"polarity\"],\n",
    "                                    size= attitude_qualities[\"size\"], \n",
    "                                    name= name_rep\n",
    "                                    )\n",
    "    return create_surface_part(knowledge_framework, surface_representation, explainable_features,  name, **kargs)\n",
    "\n",
    "\n",
    "def constructor_surface_part_from_interpretation_of_parts( interpretation_situation, knowledge_framework= None,\n",
    "                                                 physical_space= None, name= None, **kargs):\n",
    "    \"\"\"Constructor of observations\n",
    "    \n",
    "    Parameters:\n",
    "    - knowledge_framework: the knowledge framework in which this object must be created\n",
    "    - interpretation_situation: the interpretation situation selected in the given state of interpretation process\n",
    "    - physical_space: the physical representation space where the surface is to be defined, if None the one from the interpretation_situation.process is used\n",
    "        \n",
    "    Return:\n",
    "    - the created Surface Part\n",
    "    \"\"\"\n",
    "    knowledge_framework = knowledge_framework if knowledge_framework is not None else \\\n",
    "                                                         interpretation_situation.knowledge_framework\n",
    "    physical_space = get_physical_space_in_constructor(interpretation_situation, physical_space, **kargs)\n",
    "    \n",
    "    used_feature_class = knowledge_framework().Stratigraphic_Part\n",
    "    explainable_features_strati = knowledge_framework.filter_explainable_features_by_type( interpretation_situation.features, \n",
    "                                                                                   type_of_feature = used_feature_class)\n",
    "    if len(explainable_features_strati) < 2:\n",
    "        print(\"Warning: No explainable feature in the situation with this interpretation. Thus Surface can not be constructed. To be implemented. \")\n",
    "        return None\n",
    "    selected_pair_of_features = random.sample(explainable_features_strati, 2)\n",
    "    name_rep = None if name is None else name+\"_rep\"\n",
    "    return construct_complex_stratigraphic_part(knowledge_framework, selected_pair_of_features, physical_space,\n",
    "                                         name_object = name, name_rep = name_rep)\n",
    "    \n",
    "def constructor_surface_part_from_nodes(knowledge_framework, nodes, name= None, **kargs):\n",
    "    name_rep = None if name is None else name+\"_rep\"\n",
    "    plan = constructor_planar_surface_from_nodes(\n",
    "        knowledge_framework= knowledge_framework, nodes= nodes, name= name_rep\n",
    "    )\n",
    "    return create_surface_part(\n",
    "        knowledge_framework= knowledge_framework, surface_representation= plan, explained_features=[],  name= name, **kargs\n",
    "    )\n",
    "    \n",
    "def constructor_surface_part_from_coords(knowledge_framework, coords, coord_labels, name= None, **kargs):\n",
    "    name_rep = None if name is None else name+\"_rep\"\n",
    "    plan = constructor_planar_surface_from_coords(\n",
    "        knowledge_framework= knowledge_framework, coords= coords, coord_labels= coord_labels, name= name_rep\n",
    "    )\n",
    "    return create_surface_part(\n",
    "        knowledge_framework=knowledge_framework, surface_representation= plan, explained_features=[],  name= name, **kargs\n",
    "    )\n",
    "    \n",
    "def constructor_surface_part_from_center_attitude(\n",
    "    knowledge_framework, coord_labels, center, dip, dip_dir, size= None, polarity= True, name= None, **kargs\n",
    "):\n",
    "    name_rep = None if name is None else name+\"_rep\"\n",
    "    plan = constructor_planar_surface_from_center_attitude(\n",
    "        knowledge_framework, coord_labels, center, dip, dip_dir, size= size, polarity= polarity, name= name_rep\n",
    "    )\n",
    "    return create_surface_part(\n",
    "        knowledge_framework=knowledge_framework, surface_representation= plan, explained_features=[],  name= name, **kargs\n",
    "    )\n",
    "\n",
    "\n",
    "if \"Stratigraphic_Part\" in GeologicalKnowledgeFramework.registered_constructors:\n",
    "    del GeologicalKnowledgeFramework.registered_constructors[\"Stratigraphic_Part\"]\n",
    "\n",
    "GeologicalKnowledgeFramework.register_constructor(\"Stratigraphic_Part\", \n",
    "                                                  constructor= constructor_surface_part_from_interpretation_of_parts,\n",
    "                                                  condition= conditions_for_constructor_surface_part_from_interpretation_of_parts)\n",
    "\n",
    "\n",
    "GeologicalKnowledgeFramework.register_constructor(\"Stratigraphic_Part\", \n",
    "                                                  constructor= constructor_surface_part_from_interpretation,\n",
    "                                                  condition= conditions_for_constructor_surface_part_from_interpretation)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Stratigraphic part anomalies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# internal consistency anomaly\n",
    "\n",
    "def missing_representation_anomaly_constructor(knowledge_framework:GeologicalKnowledgeFramework,\n",
    "                                       object,\n",
    "                                    ):\n",
    "    \"\"\"Constructor method for creating an instance of RepresentationAnomaly\n",
    "    \n",
    "    This is an anomaly for any object with no representation.\n",
    "    \n",
    "    Parameters:\n",
    "    - object: the object with no representation\n",
    "    \"\"\"\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        raise MalissiaBaseError(\"Wrong condition for RepresentationAnomaly : knowledge framework\")\n",
    "    if (object is None) :\n",
    "        raise MalissiaBaseError(\"Wrong condition for RepresentationAnomaly : object is None\")\n",
    "    if (isinstance(object, list)) :\n",
    "        raise MalissiaBaseError(\"Wrong condition for RepresentationAnomaly : object is given as list\")\n",
    "    \n",
    "    anomaly = knowledge_framework().MissingRepresentationAnomaly(is_Related_To = [object])\n",
    "    return anomaly\n",
    "\n",
    "\n",
    "def representation_anomaly_constructor(knowledge_framework:GeologicalKnowledgeFramework,\n",
    "                                       object,\n",
    "                                       representation\n",
    "                                    ):\n",
    "    \"\"\"Constructor method for creating an instance of RepresentationAnomaly\n",
    "    \n",
    "    This is an anomaly for any object with bad representation, e.g., parameter not defined of with wrong type.\n",
    "    \n",
    "    Parameters:\n",
    "    - object: the object with a bad representation\n",
    "    - representation: the problematic representation (objects may have several representations)\n",
    "    \"\"\"\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        raise MalissiaBaseError(\"Wrong condition for RepresentationAnomaly : knowledge framework\")\n",
    "    if (object is None) or (representation is None):\n",
    "        raise MalissiaBaseError(\"Wrong condition for RepresentationAnomaly : parts is None\")\n",
    "    if (isinstance(object, list)) or (isinstance(representation, list)):\n",
    "        raise MalissiaBaseError(\"Wrong condition for RepresentationAnomaly : parts are given as lists\")\n",
    "    \n",
    "    anomaly = knowledge_framework().RepresentationAnomaly(\n",
    "            is_Related_To = [object],\n",
    "            is_Related_To_Representation = [representation]\n",
    "        )\n",
    "    return anomaly\n",
    "    \n",
    "def dipping_stratigraphy_anomaly_constructor(knowledge_framework:GeologicalKnowledgeFramework,\n",
    "                                            dipping_object):\n",
    "    \"\"\" Constructor method for creating an instance of DippingStratigraphyAnomaly\n",
    "    \n",
    "    This is an anomaly for a StratigraphicPart with a planar geometry having a dip above a threshold,\n",
    "    which represents the maximum dip a sedimentary surface could have without being non_planar.\n",
    "    \n",
    "    Parameters:\n",
    "    - dipping_object: the object being anomalously dipping\n",
    "    \"\"\"\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        raise MalissiaBaseError(\"Wrong condition for DippingStratigraphyAnomaly_constructor : knowledge framework\")\n",
    "    if dipping_object is None:\n",
    "        raise MalissiaBaseError(\"Wrong condition for DippingStratigraphyAnomaly_constructor : dipping_object is None\")\n",
    "    if isinstance(dipping_object, list):\n",
    "        if len(dipping_object) == 1:\n",
    "            dipping_object = dipping_object[0]\n",
    "        else:\n",
    "            raise MalissiaBaseError(\"Wrong condition for DippingStratigraphyAnomaly_constructor : multiple objects given, only one should be given\")\n",
    "            \n",
    "    anomaly = knowledge_framework().DippingStratigraphyAnomaly( is_Related_To = [dipping_object])\n",
    "    return anomaly\n",
    "\n",
    "# relational anomalies\n",
    "def dip_variation_anomaly_constructor(\n",
    "            knowledge_framework:GeologicalKnowledgeFramework, \n",
    "            parts:list\n",
    "        ):\n",
    "    \"\"\"Constructor method for creating an instance of DipVariationAnomaly\n",
    "    \n",
    "    This is an anomaly for a StratigraphicPart with a ComplexSurface geometry \n",
    "    when two successive PlanarSurfaces have a variation of orientation.\n",
    "    \n",
    "    Parameters:\n",
    "    - parts: a list containing exactly two surface parts identified as discontinuous\n",
    "    \"\"\"\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        raise MalissiaBaseError(\"Wrong condition for DipVariationAnomaly : knowledge framework\")\n",
    "    if parts is None:\n",
    "        raise MalissiaBaseError(\"Wrong condition for DipVariationAnomaly : parts is None\")\n",
    "    if (not isinstance(parts, list)) or (len(parts) != 2):\n",
    "        raise MalissiaBaseError(\"Wrong condition for DipVariationAnomaly : parts is not a list of length 2\")\n",
    "    \n",
    "    anomaly = knowledge_framework().DipVariationAnomaly(is_Related_To = parts)\n",
    "    return anomaly\n",
    "\n",
    "def discontinuous_stratigraphy_anomaly_constructor(\n",
    "            knowledge_framework:GeologicalKnowledgeFramework,\n",
    "            parts\n",
    "        ):\n",
    "    \"\"\"Constructor method for creating an instance of DiscontinuousStratigraphyAnomaly\n",
    "    \n",
    "    This anomaly is for StratigraphicParts with a ComplexSurface representation\n",
    "    when two successive PlanarSurfaces do not intersect properly suggesting a discontinuity\n",
    "    \n",
    "    Parameters:\n",
    "    - parts: a list containing exactly two surface parts identified as discontinuous\n",
    "    \"\"\"\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        raise MalissiaBaseError(\"Wrong condition for DiscontinuousStratigraphyAnomaly : knowledge framework\")\n",
    "    if parts is None:\n",
    "        raise MalissiaBaseError(\"Wrong condition for DiscontinuousStratigraphyAnomaly : parts is None\")\n",
    "    if (not isinstance(parts, list)) or (len(parts) != 2):\n",
    "        raise MalissiaBaseError(\"Wrong condition for DiscontinuousStratigraphyAnomaly : parts is not a list of length 2\")\n",
    "    \n",
    "    anomaly = knowledge_framework().DiscontinuousStratigraphyAnomaly(is_Related_To = parts)\n",
    "    return anomaly\n",
    "\n",
    "def polarity_anomaly_constructor(\n",
    "        knowledge_framework:GeologicalKnowledgeFramework,\n",
    "        parts:list\n",
    "    ):\n",
    "    \"\"\"Constructor method for creating an instance of PolarityAnomaly\n",
    "    \n",
    "    This should occur when two neighbour or supposedly connected surfaces have opposite polarities\n",
    "    or when a fold has two limbs with incompatible polarities.\n",
    "    \n",
    "    Parameters:\n",
    "    - parts: a list containing the two surface parts or limbs related to this anomaly\n",
    "    \"\"\"\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        raise MalissiaBaseError(\"Wrong condition for PolarityAnomaly : knowledge framework\")\n",
    "    if parts is None:\n",
    "        raise MalissiaBaseError(\"Wrong condition for PolarityAnomaly : parts is None\")\n",
    "    if (not isinstance(parts, list)) or (len(parts) != 2):\n",
    "        raise MalissiaBaseError(\"Wrong condition for PolarityAnomaly : parts is not a list of length 2\")\n",
    "    \n",
    "    anomaly = knowledge_framework().PolarityAnomaly(is_Related_To = parts)\n",
    "    return anomaly\n",
    "\n",
    "#explanation anomalies\n",
    "def explanation_anomaly_constructor(\n",
    "                                    knowledge_framework:GeologicalKnowledgeFramework,\n",
    "                                    explaining_object, \n",
    "                                    explained_object\n",
    "                                ):\n",
    "    \"\"\"Constructor method for creating an instance of ExplanationAnomaly\n",
    "    \n",
    "    For when an explained object geometry doesn't match the explaining object geometry\n",
    "    (distance between surface too big).\n",
    "    \"\"\"\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        print(\"Wrong condition for ExplanationAnomaly : knowledge framework\")\n",
    "        return False\n",
    "    if (explaining_object is None) or (explained_object is None):\n",
    "        raise MalissiaBaseError(\"Wrong condition for StratigraphyBorderAnomaly : at least one of the objects is None\")\n",
    "    if (isinstance(explaining_object, list)) or (isinstance(explained_object, list)):\n",
    "        raise MalissiaBaseError(\"Wrong condition for StratigraphyBorderAnomaly : at least one of the objects is a list\")\n",
    "    \n",
    "    anomaly = knowledge_framework().ExplanationAnomaly( \n",
    "                                            is_Related_To_Explaining_Object = [explaining_object],\n",
    "                                            is_Related_To_Explained_Object = [explained_object]\n",
    "                                        )\n",
    "    return anomaly\n",
    "\n",
    "\n",
    "\n",
    "# complex surfaces anomalies\n",
    "def complex_surface_planar_anomaly_constructor(\n",
    "            knowledge_framework:GeologicalKnowledgeFramework, \n",
    "            parts:list\n",
    "        ):\n",
    "    \"\"\"Constructor method for creating an instance of ComplexSurfacePlanarAnomaly\n",
    "    \n",
    "    This is an anomaly for a StratigraphicPart 'representation' with a planar ComplexSurface geometry \n",
    "    and the two parts of it are planar, coplanar, and parallel. It could be upgraded to include more then 2 parts\n",
    "\n",
    "    Parameters:\n",
    "    - parts: a list containing exactly two surface parts identified\n",
    "    \"\"\"\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        raise MalissiaBaseError(\"Wrong condition for ComplexSurfacePlanarAnomaly : knowledge framework\")\n",
    "    if parts is None:\n",
    "        raise MalissiaBaseError(\"Wrong condition for ComplexSurfacePlanarAnomaly : parts is None\")\n",
    "    if (not isinstance(parts, list)) or (len(parts) != 2):\n",
    "        raise MalissiaBaseError(\"Wrong condition for ComplexSurfacePlanarAnomaly : parts is not a list of length 2\")\n",
    "    \n",
    "    anomaly = knowledge_framework().ComplexSurfacePlanarAnomaly(is_Related_To = parts)\n",
    "    return anomaly\n",
    "\n",
    "def complex_surface_shared_sides_size_anomaly_constructor(\n",
    "            knowledge_framework:GeologicalKnowledgeFramework, \n",
    "            complex_surface\n",
    "        ):\n",
    "    \"\"\"Constructor method for creating an instance of ComplexSurfaceSizeSharedSidesAnomaly\n",
    "    \n",
    "    This is an anomaly for a StratigraphicPart 'representation' with a non planar ComplexSurface geometry \n",
    "    where the shared sides between their parts are not equal\n",
    "\n",
    "    Parameters:\n",
    "    - complex_surface: the anomalic complex_surface\n",
    "    \"\"\"\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        raise MalissiaBaseError(\"Wrong condition for ComplexSurfaceSizeSharedSidesAnomaly : knowledge framework\")\n",
    "\n",
    "    if (not isinstance(complex_surface, knowledge_framework().Complex_Surface)):\n",
    "        raise MalissiaBaseError(\"Wrong condition for ComplexSurfaceSizeSharedSidesAnomaly : complex_surface is not an instance of Complex_Surface\")\n",
    "    \n",
    "    if len(complex_surface.has_Part) < 2 :\n",
    "        raise MalissiaBaseError(\"Wrong condition for ComplexSurfaceSizeSharedSidesAnomaly : complex_surface has less then two parts\")\n",
    "    \n",
    "    anomaly = knowledge_framework().ComplexSurfaceSizeSharedSidesAnomaly(is_Related_To = [complex_surface])\n",
    "\n",
    "    return anomaly\n",
    "\n",
    "\n",
    "\n",
    "def complex_surface_neighbor_number_anomaly(\n",
    "            knowledge_framework:GeologicalKnowledgeFramework, \n",
    "            complex_surface\n",
    "        ):\n",
    "    \"\"\"Constructor method for creating an instance of ComplexSurfaceNeighborNumberAnomaly\n",
    "    \n",
    "    This is an anomaly for a StratigraphicPart 'representation' with a non planar ComplexSurface geometry \n",
    "    and the actual count of neighors part is not equal to the expected number (nb_parts - 1)*2. \n",
    "    \n",
    "    Parameters:\n",
    "    - complex_surface: the anomalic complexs_surface\n",
    "    \"\"\"\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        raise MalissiaBaseError(\"Wrong condition for ComplexSurfacePlanarAnomaly : knowledge framework\")\n",
    "    if complex_surface is None:\n",
    "        raise MalissiaBaseError(\"Wrong condition for ComplexSurfacePlanarAnomaly : complex_surface is None\")\n",
    "\n",
    "    \n",
    "    anomaly = knowledge_framework().ComplexSurfaceNeighborNumberAnomaly(is_Related_To = [complex_surface])\n",
    "    return anomaly\n",
    "\n",
    "def shared_side_not_parallel_anomaly(\n",
    "            knowledge_framework:GeologicalKnowledgeFramework, \n",
    "            complex_surface\n",
    "        ):\n",
    "    \"\"\"Constructor method for creating an instance of SharedSideNotParallelAnomaly\n",
    "    \n",
    "    This is an anomaly for a StratigraphicPart 'representation' with a planar ComplexSurface geometry \n",
    "    and the shared sides between the different parts are not parallel.\n",
    "\n",
    "    Parameters:\n",
    "    - parts: a list containing exactly two surface parts identified\n",
    "    \"\"\"\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        raise MalissiaBaseError(\"Wrong condition for ComplexSurfacePlanarAnomaly : knowledge framework\")\n",
    "    if complex_surface is None:\n",
    "        raise MalissiaBaseError(\"Wrong condition for ComplexSurfacePlanarAnomaly : complex_surface is None\")\n",
    "    \n",
    "    anomaly = knowledge_framework().SharedSideNotParallelAnomaly(is_Related_To = [complex_surface])\n",
    "    return anomaly\n",
    "\n",
    "# deformation related anomaly\n",
    "\n",
    "def internal_dip_variation_anomaly_two_parts_constructor(knowledge_framework, stratigraphic_part):\n",
    "    \n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        raise MalissiaBaseError(\"Wrong condition for InternalDipVariationAnomalyTwoParts : knowledge framework\")\n",
    "    if stratigraphic_part is None:\n",
    "        raise MalissiaBaseError(\"Wrong condition for InternalDipVariationAnomalyTwoParts : stratigraphic_part is None\")\n",
    "    \n",
    "    anomaly = knowledge_framework().InternalDipVariationAnomalyTwoParts(is_Related_To = [stratigraphic_part])\n",
    "    return anomaly\n",
    "\n",
    "def internal_dip_variation_anomaly_multi_parts_constructor(knowledge_framework, stratigraphic_part):\n",
    "    \n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        raise MalissiaBaseError(\"Wrong condition for InternalDipVariationAnomalyMultiParts : knowledge framework\")\n",
    "    if stratigraphic_part is None:\n",
    "        raise MalissiaBaseError(\"Wrong condition for InternalDipVariationAnomalyMultiParts : stratigraphic_part is None\")\n",
    "    \n",
    "    anomaly = knowledge_framework().InternalDipVariationAnomalyMultiParts(is_Related_To = [stratigraphic_part])\n",
    "    return anomaly\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_distance_to_surface_part(part, node, physical_space):\n",
    "    # todo : compute distance for different nodes and aggregate results depeding on the type of the object \n",
    "    node_coord = np.array(physical_space.get_object_coordinates(node, kind=\"node\")[0])\n",
    "    center_coord = np.array(physical_space.get_object_coordinates(part, kind=\"center\"))\n",
    "    normal = np.array(physical_space.get_object_coordinates(part, kind=\"normal\"))\n",
    "    normal /= np.linalg.norm(normal)\n",
    "    vec = node_coord - center_coord\n",
    "    return float(np.dot(vec, normal))\n",
    "\n",
    "def compute_surface_part_confidence_interval(part, physical_space, std_perc_size= 0.025):\n",
    "    size = physical_space.get_object_coordinates(part, kind=\"size\")\n",
    "    return 2 * std_perc_size * size\n",
    "\n",
    "def evaluate_stratigraphic_part_explanation_consistency(part, knowledge_framework, physical_space, std_perc_size= 0.025, **kargs):\n",
    "    # todo :  generate coverage anomalies (for points projecting outside of the explaining object)\n",
    "\n",
    "    # get representation\n",
    "    rep = part.has_Representation\n",
    "    if (rep is None) or (len(rep) == 0):\n",
    "        return [ missing_representation_anomaly_constructor(\n",
    "            knowledge_framework= knowledge_framework,\n",
    "            object= part)]\n",
    "    \n",
    "    # case of a Planar Stratigraphic Part\n",
    "    if (len(rep) == 1) and (isinstance(rep[0], knowledge_framework().Planar_Surface)):\n",
    "\n",
    "        explained_objects = part.explain\n",
    "        # Todo:  filter explained object and keep only those with a physical representation\n",
    "        distances = [compute_distance_to_surface_part(part, obj_i, physical_space= physical_space) for obj_i in explained_objects]\n",
    "        confidence_interval = compute_surface_part_confidence_interval(part, physical_space, std_perc_size= std_perc_size)\n",
    "        \n",
    "        # generate anomalies\n",
    "        anomalies = [explanation_anomaly_constructor(knowledge_framework, part, obj_i) \n",
    "                    for (obj_i, dist_i) in zip(explained_objects,distances)\n",
    "                    if np.abs(dist_i) > confidence_interval ]\n",
    "        return anomalies\n",
    "    \n",
    "    # small fix when part is a complex_part\n",
    "    elif (len(rep) == 1) and (isinstance(rep[0], knowledge_framework().Complex_Surface)):\n",
    "        return []\n",
    "    \n",
    "    else:\n",
    "        raise MalissiaNotImplementedYet(\"Multiple representations while evaluating consistency\")\n",
    "    \n",
    "\n",
    "def evaluate_statigraphic_part_internal_consistency(part, knowledge_framework, physical_space, max_dip= 4, **kargs):\n",
    "    \n",
    "    # get representation\n",
    "    rep = part.has_Representation\n",
    "    if (rep is None) or (len(rep) == 0):\n",
    "        return [missing_representation_anomaly_constructor(\n",
    "            knowledge_framework= knowledge_framework,\n",
    "            object= part)]\n",
    "    \n",
    "    # case of a Planar Stratigraphic Part\n",
    "    if (len(rep) == 1) and (isinstance(rep[0], knowledge_framework().Planar_Surface)):\n",
    "        return evaluate_planar_statigraphic_part_internal_consistency(\n",
    "            part= part,\n",
    "            representation= rep[0],\n",
    "            knowledge_framework= knowledge_framework, physical_space = physical_space,\n",
    "            max_dip= max_dip,\n",
    "            **kargs\n",
    "        )\n",
    "    # case of a Complex Stratigraphic Part\n",
    "    elif (len(rep) == 1) and (isinstance(rep[0], knowledge_framework().Complex_Surface)):\n",
    "        return evaluate_complex_statigraphic_part_internal_consistency(\n",
    "            representation= rep[0],\n",
    "            knowledge_framework= knowledge_framework, physical_space = physical_space,\n",
    "            **kargs\n",
    "        )\n",
    "    else:\n",
    "        raise MalissiaNotImplementedYet(\"Multiple representations while evaluating consistency\")\n",
    "\n",
    "def evaluate_planar_statigraphic_part_internal_consistency(part, representation, \n",
    "                                                           knowledge_framework, physical_space, max_dip= 4, **kargs):\n",
    "    \n",
    "    # evaluation of dip consistency\n",
    "    dip = representation.dip\n",
    "    if (dip is None) or (len(dip) == 0):\n",
    "        return [representation_anomaly_constructor(\n",
    "            knowledge_framework= knowledge_framework,\n",
    "            object= part,\n",
    "            representation= representation\n",
    "        )]\n",
    "        \n",
    "    # case of out of range dip\n",
    "    elif (dip[0] < 0) or (dip[0] > 90):\n",
    "        return [representation_anomaly_constructor(\n",
    "            knowledge_framework= knowledge_framework,\n",
    "            object= part,\n",
    "            representation= representation\n",
    "        )]\n",
    "        \n",
    "    # case of stratigraphy dipping too much\n",
    "    elif dip[0] > max_dip:\n",
    "        return [dipping_stratigraphy_anomaly_constructor(\n",
    "                    knowledge_framework= knowledge_framework,\n",
    "                    dipping_object= part\n",
    "            )]\n",
    "    else:\n",
    "        # no anomaly\n",
    "        return []\n",
    "    \n",
    "def evaluate_complex_statigraphic_part_internal_consistency(representation, knowledge_framework, physical_space,\n",
    "                                                             **kargs):\n",
    "    \n",
    "    \"\"\"\n",
    "    Method to check the geometry of the complex surface. It returns True if all conditions are met, \n",
    "        or raise an anomaly depedning on the type of the situation detected. \n",
    "\n",
    "    Parameter:\n",
    "    - complex_surface : the complex_surface\n",
    "    - physical_space : the physical_space\n",
    "    - knowledge_framework : the knowledge_framework \n",
    "    \"\"\" \n",
    "    complex_surface = representation\n",
    "\n",
    "    class_stratigraphic_part = knowledge_framework().Stratigraphic_Part\n",
    "    stratigraphic_parts = [obj for obj in complex_surface.is_Representation_Of if class_stratigraphic_part in obj.is_a]\n",
    "    if len(stratigraphic_parts) != 1 :\n",
    "        raise MalissiaBaseError('the complex_surface is representation of {} stratigraphic_part'.format(len(stratigraphic_parts)))\n",
    "\n",
    "    stratigraphic_part = stratigraphic_parts[0]\n",
    "\n",
    "    # if complex surface has two parts and parallel ==> this surface must be transformed to a simple planar surface\n",
    "    if complex_surface.non_planar != False and complex_surface.non_planar != True:\n",
    "        raise MalissiaBaseError('the complex_surface non_planar_property must be given \"True\" or \"False\"')\n",
    "    if len(complex_surface.has_Part) <2 :\n",
    "        raise MalissiaBaseError('the complex_surface must have at least two parts')\n",
    "    if len(complex_surface.has_Part) >2 and complex_surface.non_planar == False:\n",
    "        raise MalissiaNotImplementedYet('the actual algorithm handle only a non deformed complex_surface of exactly two parts') \n",
    "    \n",
    "    if len(complex_surface.has_Part) ==2 and complex_surface.non_planar == False:\n",
    "        # raise anomaly that indicates that this complex_surface will be transformed to a planar\n",
    "        return [complex_surface_planar_anomaly_constructor(knowledge_framework,complex_surface.has_Part)] \n",
    "    \n",
    "    if len(complex_surface.has_Part) >2 and complex_surface.non_planar == True:\n",
    "    # calcualate the common nodes and shared sides\n",
    "        # check if all shared sides are parallel\n",
    "        if not shared_sides_are_parallel(complex_surface  = complex_surface, knowledge_framework  = knowledge_framework, \n",
    "                                                                                   physical_space =  physical_space):\n",
    "            #he geometry of the complex surface is not conforme because shared sides are not parallel ==> undo last interpetation\n",
    "            return [shared_side_not_parallel_anomaly(knowledge_framework, complex_surface)] \n",
    "        \n",
    "        # check if all shared sides in the complex_surface has the same length in the correct allignement\n",
    "        if not shared_sides_are_equal(complex_surface  = complex_surface, knowledge_framework  = knowledge_framework, \n",
    "                                                                                   physical_space =  physical_space):\n",
    "            # raise anomaly that indicates that this complex_surface must be extended ==> look at unmatched neighbor\n",
    "            return [complex_surface_shared_sides_size_anomaly_constructor(knowledge_framework, complex_surface)]\n",
    "        \n",
    "        if not shared_sides_have_uniform_allignement(complex_surface  = complex_surface, knowledge_framework  = knowledge_framework, \n",
    "                                                                                   physical_space =  physical_space):\n",
    "            # raise anomaly that indicates that this complex_surface must be extended ==> look at unmatched neighbor\n",
    "            return [complex_surface_shared_sides_size_anomaly_constructor(knowledge_framework, complex_surface)]\n",
    "        \n",
    "        #check neighbors number and arrangement in the complex_surface\n",
    "        if not check_complex_surface_neighbor_number_and_arrangement(complex_surface  = complex_surface, knowledge_framework  = knowledge_framework, \n",
    "                                                                                   physical_space =  physical_space):\n",
    "            # the geometry of the complex surface is not conforme because the number of neighbors is not adequate with\n",
    "                                                            ## the number of parts (n-1)*2 ==> undo last interpetation\n",
    "            return [complex_surface_neighbor_number_anomaly(knowledge_framework, complex_surface)]\n",
    "         \n",
    "        # check chirality between all neighbors\n",
    "        for pair in extract_neighbors_in_complex_surface(complex_surface) :\n",
    "               if not check_chirality_projection(*pair, knowledge_framework, physical_space ):\n",
    "                   return [polarity_anomaly_constructor(knowledge_framework, parts = pair)]\n",
    "        class_folding_train = knowledge_framework().Fold_Train\n",
    "        if not any([class_folding_train in rep.is_a for rep in complex_surface.is_Representation_Of ]) :\n",
    "            return [internal_dip_variation_anomaly_multi_parts_constructor(knowledge_framework, stratigraphic_part)]\n",
    "       \n",
    "    class_fold = knowledge_framework().Fold\n",
    "    if len(complex_surface.has_Part) == 2 and complex_surface.non_planar == True and \\\n",
    "        not any([class_fold in rep.is_a for rep in complex_surface.is_Representation_Of ]) :\n",
    "        return [internal_dip_variation_anomaly_two_parts_constructor(knowledge_framework, stratigraphic_part)]\n",
    "\n",
    "    # if all checks come verified the function will return a an empty list \n",
    "    return []\n",
    "\n",
    "\n",
    "GeologicalKnowledgeFramework.register_internal_consistency_evaluator(\"Stratigraphic_Part\", \n",
    "                                                  method= evaluate_statigraphic_part_internal_consistency)\n",
    "GeologicalKnowledgeFramework.register_explanation_consistency_evaluator(\"Stratigraphic_Part\", \n",
    "                                                  method= evaluate_stratigraphic_part_explanation_consistency)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Stratigraphic Surface"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conditions_for_constructor_stratigraphic_surface(\n",
    "                                            knowledge_framework:GeologicalKnowledgeFramework,\n",
    "                                            interpretation_situation:InterpretationSituation, **kargs):\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        print(\"Wrong condition for Surface Part constructor: knowledge framework\")\n",
    "        return False\n",
    "    if (interpretation_situation is None):\n",
    "        print(\"Wrong condition for Surface Part constructor: interpretation situation\")\n",
    "        return False\n",
    "    if  (interpretation_situation.process is None) or (interpretation_situation.process.representation_space is None):\n",
    "        print(\"Wrong condition for Surface Part constructor: physical space\")\n",
    "        return False\n",
    "    if  (interpretation_situation.features is None) or (len(interpretation_situation.features) == 0):\n",
    "        print(\"Wrong condition for Surface Part constructor: features\")\n",
    "        return False\n",
    "    \n",
    "    constructed_class = knowledge_framework().Stratigraphic_Surface\n",
    "    explainable_features = knowledge_framework.filter_explainable_features(constructed_class, interpretation_situation.features)\n",
    "    if len(explainable_features) == 0:\n",
    "        print(\"Wrong condition for Surface Part constructor: No explainable feature in the situation with this interpretation. To be implemented.\")\n",
    "        return False\n",
    "    # in any other cases\n",
    "    return True\n",
    "\n",
    "def constructor_stratigraphic_surface_from_interpretation( interpretation_situation, \n",
    "                                            knowledge_framework= None,\n",
    "                                            physical_space= None, name= None, **kargs):\n",
    "    \"\"\"Constructor of observations\n",
    "    \n",
    "    Parameters:\n",
    "    - knowledge_framework: the knowledge framework in which this object must be created\n",
    "    - interpretation_situation: the interpretation situation selected in the given state of interpretation process\n",
    "    - physical_space: the physical representation space where the surface is to be defined, if None the one from the interpretation_situation.process is used\n",
    "        \n",
    "    Return:\n",
    "    - the created Stratigraphic Surface \n",
    "    \"\"\"\n",
    "    knowledge_framework = knowledge_framework if knowledge_framework is not None else interpretation_situation.knowledge_framework\n",
    "    physical_space = get_physical_space_in_constructor(interpretation_situation, physical_space, **kargs)\n",
    "    \n",
    "    constructed_class = knowledge_framework().Stratigraphic_Surface\n",
    "    explainable_features = knowledge_framework.filter_explainable_features(constructed_class,\n",
    "                                                             interpretation_situation.features)\n",
    "    if len(explainable_features) == 0:\n",
    "        print(\"Warning: No explainable feature in the situation with this interpretation. Thus, stratigraphic surface could not be constructed. To be implemented.\".format(explainable_features))\n",
    "        return None\n",
    "    # possible indications of which surface from interpretation situation \n",
    "    ## for ex : stratigraphic order, location of surfaces ...etc to be implemented\n",
    "    strati_surf = stratigraphic_surface_constructor(stratigraphic_surface_name = None, \n",
    "                                                    knowledge_framework = knowledge_framework)\n",
    "    strati_surf.explain.extend(explainable_features)\n",
    "\n",
    "    return strati_surf\n",
    "\n",
    "\n",
    "def stratigraphic_surface_constructor(stratigraphic_surface_name, knowledge_framework, indications = None, age = None, \n",
    "                                      force_creation_of_new_stratigraphic_surface = False):\n",
    "\n",
    "    stratigraphic_surface_name = 'Permian' if stratigraphic_surface_name is None and indications is None else stratigraphic_surface_name\n",
    "\n",
    "    possible_existing_instances = list(set(knowledge_framework.search(\n",
    "        name= stratigraphic_surface_name)).intersection(set(knowledge_framework().Stratigraphic_Surface.instances())))\n",
    "    if len(possible_existing_instances) == 0 :\n",
    "        return knowledge_framework().Stratigraphic_Surface(name = stratigraphic_surface_name)\n",
    "    elif len(possible_existing_instances) == 1 :\n",
    "        if force_creation_of_new_stratigraphic_surface != True :\n",
    "            print('Object {} already, exists. It will be returned'.format(possible_existing_instances[0]))\n",
    "            return possible_existing_instances[0]\n",
    "        if force_creation_of_new_stratigraphic_surface == True :\n",
    "            raise MalissiaNotImplementedYet('method to be implemented to create multiple stratigraphic surfaces with the same age.')\n",
    "            #knowledge_framework().Stratigraphic_Surface.instances(name = stratigraphic_surface_name)\n",
    "            pass\n",
    "    else:\n",
    "        print('Warning: multiple instnaces of {} with the name {} exist [{}], returning [0]'.format(knowledge_framework().Stratigraphic_Surface, \n",
    "                                                                                     stratigraphic_surface_name,  possible_existing_instances))\n",
    "        return possible_existing_instances[0]\n",
    "\n",
    "if \"Stratigraphic_Surface\" in GeologicalKnowledgeFramework.registered_constructors:\n",
    "    del GeologicalKnowledgeFramework.registered_constructors[\"Stratigraphic_Surface\"]\n",
    "\n",
    "GeologicalKnowledgeFramework.register_constructor(\"Stratigraphic_Surface\", \n",
    "                    constructor= constructor_stratigraphic_surface_from_interpretation, \n",
    "                    condition= conditions_for_constructor_stratigraphic_surface)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# internal anomalies\n",
    "def stratigraphy_border_anomaly_constructor(\n",
    "                                    knowledge_framework:GeologicalKnowledgeFramework, \n",
    "                                    stratigraphic_surface,\n",
    "                                    part,\n",
    "                                    border\n",
    "                                    ):\n",
    "    \"\"\"Constructor method for creating an instance of StratigraphyBorderAnomaly\n",
    "    \n",
    "    This anomaly is for a stratigraphic surface when its geometry doesn't reach the border of the domain\n",
    "    \n",
    "    Parameters:\n",
    "    - stratigraphic_surface: the stratigraphic_surface bearing the anomaly\n",
    "    - part: the surface part being affected by the anomaly (the one that should connect to the border)\n",
    "    - border: the border that the part should be connected to\n",
    "    \"\"\"\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        raise MalissiaBaseError(\"Wrong condition for StratigraphyBorderAnomaly : knowledge framework\")\n",
    "    if (stratigraphic_surface is None) or (part is None) or (border is None):\n",
    "        raise MalissiaBaseError(\"Wrong condition for StratigraphyBorderAnomaly : parts is None\")\n",
    "    if (isinstance(stratigraphic_surface, list)) or (isinstance(part, list)) or (isinstance(border, list)):\n",
    "        raise MalissiaBaseError(\"Wrong condition for StratigraphyBorderAnomaly : parts are given as lists\")\n",
    "    \n",
    "    anomaly = knowledge_framework().StratigraphyBorderAnomaly(is_Related_To = [stratigraphic_surface],\n",
    "                                                              is_Related_To_Part = [part],\n",
    "                                                              is_Related_To_Border = [border])\n",
    "    return anomaly\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Anomalies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Folds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "import numpy as np\n",
    "import random\n",
    "import math\n",
    "def compute_direction_toward_hinge_along_limb_1(limb_normal, fold_axis):\n",
    "    \"\"\"\n",
    "    Method to compute the direction toward the hinge along limb1. It returns an np.array([x,y,z]) vector.\n",
    "    Parameter:\n",
    "    - limb_normal:  limb1_normal\n",
    "    - fold_axis: fold_axis\n",
    "    \"\"\" \n",
    "    \n",
    "    along_limb_vec = list(map(float,-1 * np.cross(limb_normal,fold_axis)))\n",
    "    return along_limb_vec / np.linalg.norm(along_limb_vec)\n",
    "\n",
    "def compute_direction_toward_hinge_along_limb_2(limb_normal, fold_axis):\n",
    "    \"\"\"\n",
    "    Method to compute the direction toward the hinge along limb2. It returns an np.array([x,y,z]) vector.\n",
    "    Parameter:\n",
    "    - limb_normal:  limb2_normal\n",
    "    - fold_axis: fold_axis\n",
    "    \"\"\" \n",
    "    along_limb_vec = list(map(float, np.cross(limb_normal,fold_axis)))\n",
    "\n",
    "    return along_limb_vec / np.linalg.norm(along_limb_vec)\n",
    "\n",
    "def compute_s_vector(n1, c1 , n2 , c2):\n",
    "    \"\"\"\n",
    "    Method to compute the s vector that points from the first limb toward the second limb. It returns an np.array([x,y,z]) vector.\n",
    "    Parameter:\n",
    "    - n1 : first limb normal np.array([x,y,z])\n",
    "    - c1 : first limb center np.array([x,y,z])\n",
    "    - n2 : second limb normal np.array([x,y,z])\n",
    "    - c2 : second limb center np.array([x,y,z])  \n",
    "    \"\"\" \n",
    "\n",
    "    pp = np.cross(n1, n2)\n",
    "    pp_norm = np.linalg.norm(pp)\n",
    "    if pp_norm == 0:\n",
    "        raise MalissiaBaseError(\"Limbs are parallel.\")\n",
    "    pp = pp/pp_norm\n",
    "    t = n1 + n2\n",
    "    t /= np.linalg.norm(t)\n",
    "    c = c2 - c1\n",
    "    s = c - np.dot(c,t)*t - np.dot(c,pp)*pp\n",
    "    s /= np.linalg.norm(s)\n",
    "    return s\n",
    "\n",
    "def compute_fold_axis(n1, c1, n2,  c2):\n",
    "    \"\"\"\n",
    "    Method to compute the fold axis based on s vector and t 'n1+n2'. It returns an np.array([x,y,z]) vector.\n",
    "    Parameter:\n",
    "    - n1 : first limb normal np.array([x,y,z])\n",
    "    - c1 : first limb center np.array([x,y,z])\n",
    "    - n2 : second limb normal np.array([x,y,z])\n",
    "    - c2 : second limb center np.array([x,y,z])  \n",
    "    \"\"\" \n",
    "    s_vector = compute_s_vector(n1, c1, n2,  c2)\n",
    "    t = n1+n2\n",
    "    t /= np.linalg.norm(t)\n",
    "    fold_axis = np.cross(t, s_vector)\n",
    "    fold_axis /= np.linalg.norm(fold_axis)\n",
    "    return fold_axis\n",
    "\n",
    "def compute_intersection_point(plane1_center, plane1_normal, plane2_center, plane2_normal, fold_axis):\n",
    "    \"\"\"\n",
    "    Method to compute the intersection point of the projection of the normal vectors. It returns an np.array([x,y,z]) point.\n",
    "    Parameter:\n",
    "    - plane1_normal : first limb normal np.array([x,y,z])\n",
    "    - plane1_center : first limb center np.array([x,y,z])\n",
    "    - plane2_normal : second limb normal np.array([x,y,z])\n",
    "    - plane2_center : second limb center np.array([x,y,z])\n",
    "    - fold_axis = the fold_axis  \n",
    "    \"\"\" \n",
    "    # Convert input to NumPy arrays for easier vector operations\n",
    "    plane1_center = np.array(plane1_center)\n",
    "    plane1_normal = np.array(plane1_normal)\n",
    "    plane2_center = np.array(plane2_center)\n",
    "    plane2_normal = np.array(plane2_normal)\n",
    "\n",
    "    # Find the direction vector of the line of intersection\n",
    "    v2_to_hinge = compute_direction_toward_hinge_along_limb_2(plane2_normal, fold_axis)\n",
    "    c1_c2 = plane2_center - plane1_center\n",
    "    k = -np.dot(c1_c2, plane1_normal)/np.dot(plane1_normal, v2_to_hinge)\n",
    "    intersection_point = plane2_center  + k * np.array(v2_to_hinge)\n",
    "    return intersection_point\n",
    "\n",
    "def compute_point_projection_onto_line(point_to_project, line_origin, line_vector):\n",
    "    \"\"\"\n",
    "    Method to compute the projection of a point onto a line defined by a vector and an origin. It returns an np.array([x,y,z]) point.\n",
    "    Parameter:\n",
    "    - point_to_project : point_to_project np.array([x,y,z])\n",
    "    - line_origin : line_origin np.array([x,y,z])\n",
    "    - line_vector : line_vector np.array([x,y,z])  \n",
    "    \"\"\" \n",
    "\n",
    "    # Normalize the line vector\n",
    "    line_normalized = np.array(line_vector / np.linalg.norm(line_vector))\n",
    "    # Calculate the vector from the origin to the point\n",
    "    w = np.array(np.array(point_to_project) - line_origin)\n",
    "    # Project w onto the line\n",
    "    projection_length = np.dot(w, line_normalized)\n",
    "    # Find the projected point on the line\n",
    "    projected_point = line_origin + projection_length * line_normalized\n",
    "    return np.array(projected_point)\n",
    "\n",
    "def compute_distance_to_vector(point, vector_origin, vector_orientation):\n",
    "    \"\"\"\n",
    "    Method to compute the distnace of a point from a vector. It returns a float.\n",
    "    Parameter:\n",
    "    - point : point np.array([x,y,z])\n",
    "    - vector_origin : line_origin np.array([x,y,z])\n",
    "    - vector_orientation : line_vector np.array([x,y,z])  \n",
    "    \"\"\" \n",
    "    # Convert input to NumPy arrays for easier vector operations\n",
    "    point = np.array(point)\n",
    "    vector_origin = np.array(vector_origin)\n",
    "    vector_orientation = np.array(vector_orientation)\n",
    "\n",
    "    # Calculate the vector from the center to the point\n",
    "    vector_to_point = point - vector_origin\n",
    "\n",
    "    # Calculate the projection of vector_to_point onto vector_orientation\n",
    "    projection = np.dot(vector_to_point, vector_orientation) / np.dot(vector_orientation, vector_orientation) * vector_orientation\n",
    "\n",
    "    # Calculate the distance between the point and the projection\n",
    "    distance = np.linalg.norm(vector_to_point - projection)\n",
    "\n",
    "    return distance\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def compute_projection_info (projected_points,  fold_axis, tolerance = 0.2):\n",
    "    \"\"\"\n",
    "    Method to compute retrieverelated information of a projection of a point onto a vector . It returns a dict:\n",
    "    {'start_point': np.array([x,y,z]), 'end_point': np.array([x,y,z]), 'side_size': np.array([x,y,z])}.\n",
    "    It raises an error if the extreme points from list coincide or when the projected points are not collinear.\n",
    "    Parameter:\n",
    "    - projected_points : list of projected_points in the form [np.array([x,y,z]), np.array([x,y,z])....]\n",
    "    - fold_axis : vector np.array([x,y,z])  \n",
    "    \"\"\" \n",
    "    # Initialize variables to store extreme points and distances\n",
    "    max_distance = -1\n",
    "    extreme_points_max = None\n",
    "    # Calculate pairwise distances and the extreme points\n",
    "    for pair in itertools.combinations(projected_points, 2):\n",
    "        point1, point2 = pair\n",
    "        distance = np.linalg.norm(np.array(point1) - np.array(point2))\n",
    "        if distance > max_distance:\n",
    "            max_distance = distance\n",
    "            extreme_points_max = [point1, point2]\n",
    "\n",
    "    point0, point1 = np.array(extreme_points_max[0]), np.array(extreme_points_max[1])\n",
    "    if all(point0 == point1):\n",
    "        raise MalissiaBaseError ('the projected points coincide')\n",
    "    side_size = max_distance\n",
    "    vec = np.array([point1[0] - point0[0], \n",
    "           point1[1] - point0[1],\n",
    "             point1[2] - point0[2]])\n",
    "    \n",
    "    cross_product_magnitude = np.linalg.norm(np.cross(vec / np.linalg.norm(vec), fold_axis / np.linalg.norm(fold_axis)))\n",
    "    \n",
    "    if  not cross_product_magnitude <= tolerance:\n",
    "        raise MalissiaBaseError('projected points on the fold axis are not collinear')\n",
    "    if np.dot(vec, fold_axis) > 0:\n",
    "        start_point = point0\n",
    "        end_point = point1\n",
    "    else: \n",
    "        start_point = point1\n",
    "        end_point = point0\n",
    "    return {'start_point': start_point, 'end_point': end_point,\n",
    "             'side_size': side_size}\n",
    "\n",
    "def compute_side_size_and_start_point(limb_part1,  limb_part2, physical_space,  fold_axis, intersection_point, all_surfaces_nodes = None):\n",
    "    \"\"\"\n",
    "    Method to compute side_size and start_point for constructing fold limbs. It returns : float(side_size) and np.array(start_point)\n",
    "\n",
    "    Parameter:\n",
    "    - limb_part1 : limb_part1\n",
    "    - limb_part2 : limb_part2\n",
    "    - physical_space : the physical_space\n",
    "    - fold_axis : vector np.array([x,y,z])  \n",
    "    - intersection_point : intersection_point in the form of np.array([x,y,z]) \n",
    "    \"\"\" \n",
    "    if all_surfaces_nodes == None:\n",
    "        all_surfaces_nodes = [v for v in np.array(physical_space.get_object_coordinates( object= limb_part1, kind= \"nodes\")) ]\n",
    "        for v in np.array(physical_space.get_object_coordinates( object= limb_part2, kind= \"nodes\")):\n",
    "            all_surfaces_nodes.append(v) \n",
    "    else:\n",
    "        all_surfaces_nodes = all_surfaces_nodes\n",
    "    projected_nodes = []\n",
    "    for node_i in all_surfaces_nodes:\n",
    "        projected_nodes.append(compute_point_projection_onto_line(node_i, \n",
    "                intersection_point, fold_axis)) \n",
    "        \n",
    "    information = compute_projection_info(projected_nodes,  fold_axis)\n",
    "    all_distances = [compute_distance_to_vector(n_i, intersection_point, fold_axis) \n",
    "                    for n_i in all_surfaces_nodes]\n",
    "    max_distance = np.max(all_distances)\n",
    "    side_size =  information['side_size'] if information['side_size']>= max_distance else  max_distance\n",
    "    return side_size, information['start_point']\n",
    "\n",
    "def compute_shape_limb1(start_point, fold_axis, side_size,  limb_normal):\n",
    "    \"\"\"\n",
    "    Method to compute the shape of the first limb of a fold based on a start_point and a side_size and the limb_normal \n",
    "        It returns : a list of vertices [vertex0, vertex1, vertex2, vertex3]\n",
    "\n",
    "    Parameter:\n",
    "    - start_point : point np.array([x,y,z])\n",
    "    - fold_axis : vector np.array([x,y,z])\n",
    "    - side_size : float \n",
    "    - limb_normal : vector np.array([x,y,z])  \n",
    "    \"\"\" \n",
    "    vertex0 = start_point\n",
    "    vertex1 = compute_endpoint(vertex0, fold_axis, side_size)\n",
    "    vertex2 = compute_endpoint(vertex1, \n",
    "                               (-compute_direction_toward_hinge_along_limb_1(limb_normal,\n",
    "                                fold_axis)), side_size)\n",
    "    vertex3 = compute_endpoint(vertex2, -fold_axis, side_size)\n",
    "    return [vertex0, vertex1, vertex2, vertex3]   \n",
    "\n",
    "def compute_shape_limb2( vertex0, vertex1 , fold_axis, side_size,  limb_normal):\n",
    "    \"\"\"\n",
    "    Method to compute the shape of the second limb of a fold based on a vertex0, vertex1; a side_size and the limb_normal \n",
    "        It returns : a list of vertices [vertex0, vertex1, vertex2, vertex3]\n",
    "\n",
    "    Parameter:\n",
    "    - vertex0 : point np.array([x,y,z])\n",
    "    - vertex1 : point np.array([x,y,z])\n",
    "    - fold_axis : vector np.array([x,y,z])\n",
    "    - side_size : float \n",
    "    - limb_normal : vector np.array([x,y,z])  \n",
    "    \"\"\" \n",
    "    vertex0 = vertex0\n",
    "    vertex1 = vertex1\n",
    "    vertex2 = compute_endpoint(vertex1, \n",
    "                               (-compute_direction_toward_hinge_along_limb_2(limb_normal,\n",
    "                                fold_axis)), side_size)\n",
    "    vertex3 = compute_endpoint(vertex2,fold_axis, side_size)\n",
    "    return [vertex0, vertex1, vertex2, vertex3]   \n",
    "\n",
    "def compute_endpoint(start_point, direction_vector, distance):\n",
    "    \"\"\"\n",
    "    Method to compute a projection of a point toward a direction defined by a vector and at a distance.\n",
    "        It returns :point np.array([x,y,z])\n",
    "\n",
    "    Parameter:\n",
    "    - start_point : point np.array([x,y,z])\n",
    "    - direction_vector : vector np.array([x,y,z])\n",
    "    - distance : float \n",
    "    \"\"\" \n",
    "    direction_vector = np.array(direction_vector)\n",
    "    direction_vector = direction_vector/np.linalg.norm(direction_vector)\n",
    "    endpoint = [float(start_point[i] + distance * direction_vector[i]) for i in range(len(start_point))]\n",
    "    return endpoint\n",
    "\n",
    "def compute_axial_surface_normal(limb1_normal, limb2_normal, fold_axis):\n",
    "    \"\"\"\n",
    "    Method to compute the axial surface normal vector based on the first limb ormal, second limb normal and the fold axis.\n",
    "        It returns :a vector np.array([x,y,z])\n",
    "\n",
    "    Parameter:\n",
    "    - limb1_normal : vector np.array([x,y,z])\n",
    "    - limb2_normal : vector np.array([x,y,z])\n",
    "    - fold_axis : vector np.array([x,y,z])\n",
    "    \"\"\" \n",
    "    limb1_normal = np.array(limb1_normal).astype(float)\n",
    "    limb2_normal = np.array(limb2_normal).astype(float)\n",
    "    axial_surface_normal = np.cross(fold_axis, limb1_normal+limb2_normal)\n",
    "    return axial_surface_normal / np.linalg.norm(axial_surface_normal)\n",
    "\n",
    "def limb1_constuctor(fold, knowledge_framework, physical_space,\n",
    "                     fold_axis = None, side_size = None, limb1_normal = None,\n",
    "                     start_point = None, \n",
    "                     limb1_nodes_tempo = None, use_original_part_as_limb1 = False , original_part = None):\n",
    "    \"\"\"\n",
    "    Method to construct the first limb of a fold. If limb1_nodes_tempo are not given, \n",
    "    the method will compute the nodes from the start_point,fold_axis, side_size and the limb1_normal. In this case these parameters must be given.\n",
    "        It returns : an object of type limb and stratigraphic_part.\n",
    "\n",
    "    Parameter:\n",
    "    - fold : object of type fold\n",
    "    - knowledge_framework : the knowledge_framework\n",
    "    - fold_axis = vector np.array([x,y,z])\n",
    "    - side_size = float\n",
    "    - limb1_normal = vector np.array([x,y,z]\n",
    "    - start_point = point np.array([x,y,z]\n",
    "    - limb1_nodes_tempo : [vertex0, vertex1, vertex2, vertex3]\n",
    "    \"\"\" \n",
    "    if use_original_part_as_limb1 == False:\n",
    "\n",
    "        # must add checking if not all none\n",
    "        limb1_nodes_tempo = limb1_nodes_tempo if limb1_nodes_tempo is not None else compute_shape_limb1(start_point,fold_axis, side_size,limb1_normal) \n",
    "    \n",
    "        ## format them for the knowledgeframework\n",
    "        \n",
    "        coor_lab = physical_space.coordinate_labels\n",
    "        limb1_nodes = [\n",
    "            constructor_point(knowledge_framework, coor_lab ,[float(x) for x in limb1_nodes_tempo[0]]),\n",
    "            constructor_point(knowledge_framework, coor_lab,[float(x) for x in limb1_nodes_tempo[1]]),\n",
    "            constructor_point(knowledge_framework, coor_lab ,[float(x) for x in limb1_nodes_tempo[2]]),\n",
    "            constructor_point(knowledge_framework, coor_lab,[float(x) for x in limb1_nodes_tempo[3]])\n",
    "            ]\n",
    "        ## create the stratigraphic_part1 that will be the first fold limb\n",
    "        strat_part_limb1 = constructor_surface_part_from_nodes(knowledge_framework = knowledge_framework,\n",
    "                                                    nodes= limb1_nodes, \n",
    "                                                    )\n",
    "    else:\n",
    "        if original_part is None:\n",
    "            raise MalissiaBaseError('original part must be given if use_original_part_as_limb1 is True')\n",
    "        else: \n",
    "            strat_part_limb1 = original_part\n",
    "\n",
    "    ## define this stratigraphic part as the first fold limb\n",
    "    if knowledge_framework().Fold_Limb not in strat_part_limb1.is_a:\n",
    "        strat_part_limb1.is_a.append(knowledge_framework().Fold_Limb)\n",
    "\n",
    "    return strat_part_limb1\n",
    "\n",
    "def limb2_constuctor( fold, knowledge_framework,  physical_space,\n",
    "                     vertex0 = None , vertex1 = None , fold_axis = None , side_size = None ,\n",
    "                       limb2_normal = None ,limb2_nodes_tempo = None, use_original_part_as_limb2 = False , original_part = None):\n",
    "    \"\"\"\n",
    "    Method to construct the first limb of a fold. If limb2_nodes_tempo are not given, \n",
    "    the method will compute the nodes from the start_point,fold_axis, side_size and the limb2_normal. In this case these parameters must be given.\n",
    "        It returns : an object of type limb and stratigraphic_part.\n",
    "\n",
    "    Parameter:\n",
    "    - fold : object of type fold\n",
    "    - knowledge_framework : the knowledge_framework\n",
    "    - vertex0 = point np.array([x,y,z]\n",
    "    - vertex1 = point np.array([x,y,z]\n",
    "    - fold_axis = vector np.array([x,y,z])\n",
    "    - side_size = float\n",
    "    - limb2_normal = vector np.array([x,y,z]\n",
    "    - limb2_nodes_tempo : [vertex0, vertex1, vertex2, vertex3]\n",
    "    \"\"\" \n",
    "    if use_original_part_as_limb2 == False:\n",
    "\n",
    "        limb2_nodes_tempo = limb2_nodes_tempo if limb2_nodes_tempo is not None else compute_shape_limb2(vertex0= vertex0,vertex1= vertex1,\n",
    "                                        fold_axis= fold_axis, \n",
    "                                        side_size = side_size,\n",
    "                                        limb_normal= limb2_normal) \n",
    "        \n",
    "        ## format them for the knowledgeframework\n",
    "        coor_lab = physical_space.coordinate_labels\n",
    "        limb2_nodes = [\n",
    "            constructor_point(knowledge_framework, coor_lab,[float(x) for x in limb2_nodes_tempo[0]],),\n",
    "            constructor_point(knowledge_framework, coor_lab,[float(x) for x in limb2_nodes_tempo[1]]),\n",
    "            constructor_point(knowledge_framework, coor_lab,[float(x) for x in limb2_nodes_tempo[2]]),\n",
    "            constructor_point(knowledge_framework, coor_lab,[float(x) for x in limb2_nodes_tempo[3]])\n",
    "            ]\n",
    "        \n",
    "        ## create the stratigraphic_part1 that will be the first fold limb\n",
    "        strat_part_limb2 = constructor_surface_part_from_nodes(knowledge_framework = knowledge_framework,\n",
    "                                                    nodes= limb2_nodes, )\n",
    "    else:\n",
    "        if original_part is None:\n",
    "            raise MalissiaBaseError('original part must be given if use_original_part_as_limb1 is True')\n",
    "        else: \n",
    "            strat_part_limb2 = original_part\n",
    "\n",
    "    ## define this stratigraphic part as the first fold limb\n",
    "    if knowledge_framework().Fold_Limb not in strat_part_limb2.is_a:\n",
    "        strat_part_limb2.is_a.append(knowledge_framework().Fold_Limb)\n",
    "    \n",
    "    return strat_part_limb2\n",
    "\n",
    "def axial_surface_constructor(knowledge_framework, physical_space, fold, limb1_normal, limb2_normal,\n",
    "                               fold_axis, midpoint, side_size):\n",
    "    \"\"\"\n",
    "    Method to construct the fold axial surface. It returns : an object of type planar surface.\n",
    "\n",
    "    Parameter:\n",
    "    - fold : object of type fold\n",
    "    - knowledge_framework : the knowledge_framework\n",
    "    - fold_axis = vector np.array([x,y,z])\n",
    "    - limb1_normal = vector np.array([x,y,z]\n",
    "    - physical_space: the physical_space\n",
    "    - limb2_normal : vector np.array([x,y,z]\n",
    "    - midpoint : midpoint between the two shared vertices of the two limbs\n",
    "    - side_size : float \n",
    "    \"\"\" \n",
    "    axial_surf_normal = compute_axial_surface_normal(limb1_normal ,limb2_normal, fold_axis)\n",
    "    dip, dip_dir, polarity = physical_space.compute_dip_dir_from_normal(axial_surf_normal)  \n",
    "\n",
    "    \n",
    "    axial_surface_representtation = constructor_planar_surface_from_center_attitude(knowledge_framework= knowledge_framework, \n",
    "                                                    coord_labels= physical_space.coordinate_labels,\n",
    "                                                            center= midpoint,\n",
    "                                                       size= side_size*3, dip= dip, dip_dir= dip_dir, polarity= polarity,\n",
    "                                                       name= \"{}_axial_surface_rep\".format(fold.name)) \n",
    "                                                  \n",
    "    axial_surface = knowledge_framework().Axial_Surface(name = \"{}_axial_surface\".format(fold.name), \n",
    "                                                        has_Representation = [axial_surface_representtation])\n",
    "    return axial_surface\n",
    "\n",
    "def fold_constructor_from_two_stratigraphic_parts(candidate_stratigraphic_part1 = None, \n",
    "                     candidate_stratigraphic_part2 = None,  \n",
    "                    candidate_limb_part1 = None, candidate_limb_part2 = None,\n",
    "                     physical_space= None, name= None, \n",
    "                     knowledge_framework= None, difference_in_dipping_anomaly = None, **kargs, \n",
    "                      ):\n",
    "    \"\"\"\n",
    "    Method to construct a fold from two stratigraphic parts. If the stratigraphic parts are not designate as candidate_limb_part1 and candidate_limb_part2, \n",
    "    the method takes candidate_stratigraphic_part1 and candidate_stratigraphic_part2 and makes a fold based on a random assignements of limbs order.\n",
    "    It returns : an object of type fold with its properties and relations \n",
    "        (has_Axial_Surface, has_Fold_Axis, has_Limb1, has_Limb2)\n",
    "\n",
    "    Parameter:\n",
    "    - candidate_stratigraphic_part1 = the candidate_stratigraphic_part1\n",
    "    - candidate_stratigraphic_part2 = the candidate_stratigraphic_part2,  \n",
    "    - candidate_limb_part1 = the candidate_limb_part1\n",
    "    - candidate_limb_part2 = the candidate_limb_part2\n",
    "    - physical_space= the physical_space \n",
    "    - name= str possible name of the new fold, \n",
    "    - knowledge_framework : the knowledge_framework\n",
    "     \n",
    "    **kargs :\n",
    "\n",
    "    \"\"\" \n",
    "    # check for errors in the inputs\n",
    "    if candidate_limb_part1 != None and  candidate_limb_part2 != None:\n",
    "        limb_part1 = candidate_limb_part1\n",
    "        limb_part2 = candidate_limb_part2\n",
    "    elif candidate_stratigraphic_part1 is not None and candidate_stratigraphic_part2 is not None:\n",
    "        choice =  random.randint(1, 2)\n",
    "        if choice == 1 :\n",
    "            limb_part1 = candidate_stratigraphic_part1\n",
    "            limb_part2 = candidate_stratigraphic_part2\n",
    "        else : \n",
    "            limb_part2 = candidate_stratigraphic_part1\n",
    "            limb_part1 = candidate_stratigraphic_part2\n",
    "    else :\n",
    "        raise MalissiaBaseError('two cnadidate stratigraphic parts must be given')\n",
    "    \n",
    "    knowledge_framework = knowledge_framework #if knowledge_framework is not None else .knowledge_framework\n",
    "    #constructed_class = knowledge_framework().Chevron_Fold  ==> to be used with interpretation_situation but need to specficy which str_part as limb 1 or 2\n",
    "    #explainable_features = knowledge_framework.filter_explainable_features(constructed_class, interpretation_situation.features)\n",
    "    # creating an instance of a Chevron_Fold\n",
    "    physical_space = physical_space # add checking part\n",
    "\n",
    "    # check if the stratigraphic parts representations are already parts of an existing complex_surface\n",
    "    intersection = list(set(limb_part1.has_Representation[0].is_Part_Of).intersection(set(limb_part2.has_Representation[0].is_Part_Of)).intersection(set(knowledge_framework().Complex_Surface.instances())))\n",
    "    if len(intersection) > 0:\n",
    "        for inter_i in intersection:\n",
    "            possible_folds =  multiple_fold_detector_in_deformed_stratigraphic_part(deformed_stratigraphic_part = None, physical_space = physical_space,\n",
    "                                                                                     knowledge_framework = knowledge_framework ,force_complex_surface = inter_i )\n",
    "            if len(possible_folds) > 0 :\n",
    "                if len(possible_folds)==1:\n",
    "                    print('Warning: {} and {} already limbs of an existing fold {}. This latter will be returned'.format(limb_part1.name, limb_part2.name, possible_folds[0].name))\n",
    "                    return possible_folds[0]\n",
    "                if len(possible_folds) > 1:\n",
    "                    print('Warning: {} and {} are limbs of of multiple folds {} return the first of the list {}.'.format(limb_part1.name, limb_part2.name, possible_folds,  possible_folds[0].name))\n",
    "                    return possible_folds[0]\n",
    "\n",
    "\n",
    "\n",
    "    \n",
    "    # get candidate limbs paramters\n",
    "    n1 = np.array(physical_space.get_object_coordinates( object= limb_part1, kind= \"normal\")) \n",
    "    n2 = np.array(physical_space.get_object_coordinates( object= limb_part2, kind= \"normal\")) \n",
    "    c1 = np.array(physical_space.get_object_coordinates( object= limb_part1, kind= \"center\")) \n",
    "    c2 = np.array(physical_space.get_object_coordinates( object= limb_part2, kind= \"center\"))\n",
    "    # create the fold\n",
    "    fold = knowledge_framework().Chevron_Fold()\n",
    "    # get initial fold parameters\n",
    "    fold_axis = compute_fold_axis(n1, c1, n2, c2)\n",
    "    intersection_point = compute_intersection_point(plane1_center=c1, \n",
    "                                                    plane1_normal=n1,plane2_center=c2, \n",
    "                                                    plane2_normal= n2, fold_axis= fold_axis)\n",
    "    \n",
    "    midpoint = None\n",
    "    nodes_limb1 = np.array(physical_space.get_object_coordinates( object= limb_part1, kind= \"nodes\"))\n",
    "    nodes_limb2 = np.array(physical_space.get_object_coordinates( object= limb_part2, kind= \"nodes\"))\n",
    "    common_nodes = common_two_nodes_two_planars(nodes_limb1, nodes_limb2, return_error = False)\n",
    "    if common_nodes is not None:\n",
    "        print(' will use two')\n",
    "        midpoint = (np.array(common_nodes[0]) + np.array(common_nodes[1])) /2 \n",
    "        side_size = float(np.linalg.norm((np.array(common_nodes[0]) - np.array(common_nodes[1]))))\n",
    "        strat_part_limb1 = limb1_constuctor(fold = fold, knowledge_framework = knowledge_framework, physical_space= physical_space, use_original_part_as_limb1= True, original_part= limb_part1)\n",
    "        strat_part_limb2 = limb1_constuctor(fold = fold, knowledge_framework = knowledge_framework, physical_space= physical_space, use_original_part_as_limb1= True, original_part= limb_part2)\n",
    "    else:\n",
    "\n",
    "        ## get side_size and start point\n",
    "        side_size, start_point = compute_side_size_and_start_point(limb_part1 = limb_part1,  limb_part2 = limb_part2,\n",
    "                                    physical_space = physical_space,  fold_axis = fold_axis, \n",
    "                                    intersection_point = intersection_point)\n",
    "        \n",
    "        # now create limbs \n",
    "        strat_part_limb1 = limb1_constuctor(start_point = start_point, \n",
    "                                            fold_axis = fold_axis, side_size = side_size, \n",
    "                                            limb1_normal = n1, fold = fold, \n",
    "                                            knowledge_framework = knowledge_framework, physical_space= physical_space)\n",
    "        ## get surface1 nodes to pass them for the second limb\n",
    "        limb1_nodes_tempo = compute_shape_limb1(start_point,fold_axis, side_size,n1) # repeated but a must\n",
    "        vertex0_for_limb2, vertex1_for_limb2 = limb1_nodes_tempo[1],limb1_nodes_tempo[0]\n",
    "        ## create second limb \n",
    "        strat_part_limb2 = limb2_constuctor(vertex0 = vertex0_for_limb2, \n",
    "                                            vertex1 = vertex1_for_limb2, \n",
    "                                            fold_axis = fold_axis, side_size = side_size, limb2_normal = n2,\n",
    "                                            fold = fold, knowledge_framework = knowledge_framework, physical_space= physical_space)\n",
    "\n",
    "\n",
    "\n",
    "    # create axial_surface and its representation \n",
    "    coord_labels = physical_space.coordinate_labels\n",
    "    midpoint = [float((i1 + i2) / 2) for i1, i2 in zip(limb1_nodes_tempo[1],limb1_nodes_tempo[0])] if midpoint is None else midpoint\n",
    "\n",
    "    axial_surface = axial_surface_constructor(knowledge_framework = knowledge_framework, physical_space = physical_space,\n",
    "                                               fold = fold, limb1_normal = n1, limb2_normal = n2, fold_axis = fold_axis,\n",
    "                                                 midpoint = midpoint, side_size = side_size)\n",
    "    # foramt the fold axis\n",
    "    fold_axis_vector_rep = constructor_vector(knowledge_framework, coord_labels, \n",
    "                                              [float(x) for x in fold_axis], name= \"{}_fold_axis_rep\".format(fold.name))\n",
    "    fold_axis_object = knowledge_framework().Fold_Axis(name = \"{}_fold_axis\".format(fold.name), \n",
    "                                                       has_Representation = [fold_axis_vector_rep])\n",
    "    # attach paramters and objects to the fold \n",
    "    strati_graphic_part = construct_complex_stratigraphic_part(knowledge_framework,[strat_part_limb1, strat_part_limb2], physical_space )\n",
    "    strati_graphic_part_rep = strati_graphic_part.has_Representation\n",
    "    fold.has_Representation = strati_graphic_part_rep\n",
    "    if difference_in_dipping_anomaly is not None:\n",
    "        fold.explain.append(difference_in_dipping_anomaly)\n",
    "    \n",
    "    fold.has_Axial_Surface= [axial_surface] \n",
    "    fold.has_Fold_Axis =  [fold_axis_object]\n",
    "    fold.has_Limb1 = [strat_part_limb1]\n",
    "    fold.has_Limb2 = [strat_part_limb2]\n",
    "    return  fold\n",
    "\n",
    "\n",
    "\n",
    "def choose_square_side(limb_nodes):\n",
    "    \"\"\"\n",
    "    Method to choose a square side index based on four nodes.It returns a square side index\n",
    "\n",
    "    Parameter:\n",
    "    - limb_nodes : [vertex0, vertex1, vertex2, vertex3]\n",
    "    \"\"\" \n",
    "    z = limb_nodes[:,2]\n",
    "    dz1 = np.abs(z[1] - z[0])\n",
    "    dz2 = np.abs(z[2] - z[1])\n",
    "    if dz1 < dz2:\n",
    "        selected_indices = [0,2]\n",
    "    elif dz1 > dz2:\n",
    "        selected_indices = [1,3]\n",
    "    else:\n",
    "        selected_indices = np.arange(4)\n",
    "    return random.choice(selected_indices)\n",
    "\n",
    "def get_square_side(limb_nodes, i):\n",
    "    \"\"\"\n",
    "    Method to get a square side based on its index .It returns a square side start, end points and the vector between them [nodes[0], nodes[1], vec].\n",
    "\n",
    "    Parameter:\n",
    "    - limb_nodes : [vertex0, vertex1, vertex2, vertex3]\n",
    "    - i : side_index int 0-3\n",
    "    \"\"\" \n",
    "    edges = np.array([[0,1],[1,2],[2,3],[3,0]])\n",
    "    nodes = limb_nodes[edges[i]]\n",
    "    vec = nodes[1] - nodes[0]\n",
    "    return [nodes[0], nodes[1], vec]\n",
    "\n",
    "def compute_complement_angle(angle_radians):\n",
    "    \"\"\"\n",
    "    Method to compute the complement angle to 180. It returns a float in radians.\n",
    "    Parameter:\n",
    "    - angle_radians : initial angle type float in radians \n",
    "    \"\"\"     \n",
    "    # Calculate the complement in radians\n",
    "    return  math.pi -angle_radians\n",
    "\n",
    "def rotate_vector_around_axis(n1, p, theta_rad ):\n",
    "    \"\"\"\n",
    "    Method to compute a vector rotation around another vector by a given angle. It returns an np.array([x,y,z]) vector.\n",
    "    Parameter:\n",
    "    - n1 : the vector to be rotated, in the form of np.array([x,y,z]) vector\n",
    "    - p :  the vector on which n1 will be rotated, in the form of np.array([x,y,z]) vector\n",
    "    - theta_rad : a rotation angle in radians as type float\n",
    "    \"\"\" \n",
    "    n1 = n1/ np.linalg.norm(n1)\n",
    "    # Calculate the rotation matrix\n",
    "    # Normalize the direction vector p over which the rotation will be performed\n",
    "    p = p / np.linalg.norm(p)\n",
    "    \n",
    "    # Calculate the cross product matrix of p\n",
    "    P = np.array([\n",
    "        [0, -p[2], p[1]],\n",
    "        [p[2], 0, -p[0]],\n",
    "        [-p[1], p[0], 0]\n",
    "    ])\n",
    "    # Calculate the rotation matrix using the Rodriguez formula\n",
    "    R = np.eye(3) + np.sin(theta_rad) * P + (1 - np.cos(theta_rad)) * np.dot(P, P)\n",
    "    # Step 2: Apply the rotation to n1\n",
    "    rotated_n1 = np.round(np.array(np.dot(R, n1)),8) \n",
    "    return rotated_n1 / np.linalg.norm(np.dot(R, n1))\n",
    "\n",
    "def fold_constructor_one_stratigraphic_part(candidate_stratigraphic_part,\n",
    "                                            knowledge_framework, physical_space, \n",
    "                                            name= None,  fold_opening_angle_degree  = 90., \n",
    "                                                 force_limb_assignment = None , \n",
    "                                                 force_fold_type = None , \n",
    "                                                 chosen_side_index = None, dipping_anomaly = None, \n",
    "                                                   **kargs, ):\n",
    "    \"\"\"\n",
    "    Method to compute a fold based on one candidate limb part. The candidate limb part could be assigned as the \n",
    "    first fold limb or the second. The fold type could be forced a type 'anticline' or 'syncline' must be given.\n",
    "    The construction could be established on a chosen side of the candidate limb part representation.\n",
    "        If a force_limb_assignment, force_fold_type and chosen_side_index are not given, the method will make a random choice.\n",
    "    The method returns : an object of type fold with its properties and relations \n",
    "    Parameter:\n",
    "    - candidate_stratigraphic_part : the candidate_stratigraphic_part as one fold limbs\n",
    "    - fold_opening_angle_degree  : the opening angle of the fold limbs, by default 90 degree,\n",
    "    - physical_space= thephysical_space \n",
    "    - name : possible name of the resulting fold, as type str \n",
    "    - knowledge_framework : the knowledge_framework \n",
    "    - force_limb_assignment : assignement of the candidate limb part as limb1 or 2 a value from [1,2] must be given\n",
    "    - force_fold_type  : a fold type defined by the stratigraphic part polarty, if given a value from ['anticline','syncline'] mut be chosen\n",
    "    - chosen_side_index : an index of the chosen side on which the constructed limb will be attached to the candidate limb part an integer value between 0-3 must be chosen\n",
    "     \n",
    "    \"\"\" \n",
    "    # initial error checking:\n",
    "    #constructed_class = knowledge_framework().Chevron_Fold  ==> to be used with interpretation_situation but need to specficy which str_part as limb 1 or 2\n",
    "    #explainable_features = knowledge_framework.filter_explainable_features(constructed_class, interpretation_situation.features)\n",
    "    # creating an instance of a Chevron_Fold\n",
    "\n",
    "\n",
    "    ##  make a choice of the limbs assignement if it is not suggesed\n",
    "    initial_limb = force_limb_assignment if force_limb_assignment is not None else random.choice([1,2]) \n",
    "    if initial_limb not in (1,2):  \n",
    "        raise MalissiaBaseError('The choice of which limb could not be be made, try giving force_limb_assignment a value of 1 or 2')\n",
    "    ##  make a choice of fold type if it is not suggesed\n",
    "    fold_type = force_fold_type if force_fold_type is not None else random.choice(['anticline','syncline'])\n",
    "    if fold_type not in ['anticline','syncline']: \n",
    "        raise MalissiaBaseError('The choice of fold type could not be made, try giving force_limb_assignment a value of anticline syncline')\n",
    "    \n",
    "    # get candidate limb nodes coordiantes, center \n",
    "    candidate_limb_nodes = physical_space.get_object_coordinates( object= candidate_stratigraphic_part, kind= \"nodes\")\n",
    "    candidate_limb_center = physical_space.get_object_coordinates( object= candidate_stratigraphic_part, kind= \"center\")\n",
    "    \n",
    "    # choose a side to be used as fold axis\n",
    "    chosen_side_index = chosen_side_index if chosen_side_index is not None else choose_square_side(candidate_limb_nodes)\n",
    "    chosen_side = get_square_side(candidate_limb_nodes, chosen_side_index)\n",
    "    if len (chosen_side) == 0 :\n",
    "        raise MalissiaBaseError('the algorithm could not chose a square side')\n",
    "    # get a midpoint of the side\n",
    "    midpoint = np.mean((chosen_side[0], chosen_side[1]), axis=0)\n",
    "    # compute direction toward the chosen fold axis using the midpoint\n",
    "    vector_to_axis = midpoint -candidate_limb_center \n",
    "    # get an initial normal \n",
    "    initial_normal = physical_space.get_object_coordinates( object= candidate_stratigraphic_part, kind= \"normal\")\n",
    "    # propose a fold axis\n",
    "    proposed_fold_axis = np.cross(initial_normal, vector_to_axis) / np.linalg.norm(np.cross(initial_normal, vector_to_axis))\n",
    "    \n",
    "\n",
    "    # based on limb assignement : \n",
    "    ## keep the fold axis if limb 1 and choose the proper angle based on the fold type\n",
    "    if initial_limb == 1:\n",
    "        fold_opening_angle_degree = fold_opening_angle_degree if fold_type == 'anticline' else -fold_opening_angle_degree\n",
    "\n",
    "    ## invert  the fold axis if limb 2 and choose the proper angle based on the fold type\n",
    "    if initial_limb == 2:\n",
    "        proposed_fold_axis *= -1\n",
    "        fold_opening_angle_degree = fold_opening_angle_degree if fold_type == 'syncline' else -fold_opening_angle_degree\n",
    "\n",
    "    # get the angle of rotation in rad based on the openning angle\n",
    "    angle_of_normal_rotation_rad =  compute_complement_angle(np.deg2rad(fold_opening_angle_degree))\n",
    "\n",
    "    # rotate the initial normal over the fold axis \n",
    "    computed_rotated_normal = rotate_vector_around_axis(n1=initial_normal, \n",
    "                                                        p= proposed_fold_axis, \n",
    "                                                        theta_rad= angle_of_normal_rotation_rad)\n",
    "    # compute a side size based on the chosen side\n",
    "    side_size  = np.linalg.norm(chosen_side[1] - chosen_side[0])\n",
    "    # create the fold\n",
    "    fold = knowledge_framework().Chevron_Fold()\n",
    "\n",
    "    # construct now the stratigraphic part of the second limb based on the assignement (1 or 2)\n",
    "    \n",
    "    if initial_limb == 1:\n",
    "        limb1 = candidate_stratigraphic_part\n",
    "        limb2_v1 = chosen_side[1]\n",
    "        limb2_v2 = chosen_side[0]\n",
    "        direction_toward_hinge_2 = compute_direction_toward_hinge_along_limb_2(computed_rotated_normal, proposed_fold_axis)\n",
    "        limb2_v3 = compute_endpoint(limb2_v2, -direction_toward_hinge_2, side_size)\n",
    "        limb2_v4 = compute_endpoint(limb2_v3, proposed_fold_axis, side_size)\n",
    "        limb2_nodes = np.array([limb2_v1, limb2_v2, limb2_v3, limb2_v4])\n",
    "        limb2 = limb2_constuctor(fold = fold, knowledge_framework = knowledge_framework, physical_space= physical_space, limb2_nodes_tempo= limb2_nodes )\n",
    "\n",
    "    if initial_limb == 2:\n",
    "        limb2 = candidate_stratigraphic_part\n",
    "        limb1_v1 = chosen_side[1]\n",
    "        limb1_v2 =chosen_side[0]\n",
    "        direction_toward_hinge_1 = compute_direction_toward_hinge_along_limb_1(computed_rotated_normal, proposed_fold_axis)\n",
    "        limb1_v3 = compute_endpoint(limb1_v2, -direction_toward_hinge_1, side_size)\n",
    "        limb1_v4 = compute_endpoint(limb1_v3, -proposed_fold_axis, side_size)\n",
    "        limb1_nodes = np.array([limb1_v1, limb1_v2, limb1_v3, limb1_v4]) \n",
    "        limb1 = limb1_constuctor(fold = fold, knowledge_framework = knowledge_framework, physical_space= physical_space, limb1_nodes_tempo= limb1_nodes )\n",
    "        \n",
    "    # now generate fold parameters    \n",
    "    # create axial_surface and its representation \n",
    "    \n",
    "     # use a midpoint between the vertices of the chosen side as a center, this must be changed of the side is no longer chosen as the fold axis\n",
    "    n1 = np.array(physical_space.get_object_coordinates( object= limb1, kind= \"normal\")) \n",
    "    n2 = np.array(physical_space.get_object_coordinates( object= limb2, kind= \"normal\")) \n",
    "    axial_surface = axial_surface_constructor(knowledge_framework = knowledge_framework, physical_space = physical_space,\n",
    "                                               fold = fold, limb1_normal = n1, limb2_normal = n2, fold_axis = proposed_fold_axis,\n",
    "                                                 midpoint = midpoint.tolist(), side_size = float(side_size))\n",
    "    # format the fold axis\n",
    "    fold_axis_vector_rep = constructor_vector(knowledge_framework, physical_space.coordinate_labels, \n",
    "                                              [float(x) for x in proposed_fold_axis], name= \"{}_fold_axis_rep\".format(fold.name))\n",
    "    fold_axis_object = knowledge_framework().Fold_Axis(name = \"{}_fold_axis\".format(fold.name), \n",
    "                                                       has_Representation = [fold_axis_vector_rep])\n",
    "    \n",
    "    strati_graphic_part = construct_complex_stratigraphic_part(knowledge_framework,[limb1, limb2], physical_space )\n",
    "    strati_graphic_part_rep = strati_graphic_part.has_Representation\n",
    "    fold.has_Representation = strati_graphic_part_rep\n",
    "    \n",
    "    if dipping_anomaly is not None:\n",
    "        fold.explain.append(dipping_anomaly)\n",
    "\n",
    "    # attach parameters and objects to the fold \n",
    "    fold.has_Axial_Surface= [axial_surface] \n",
    "    fold.has_Fold_Axis =  [fold_axis_object]\n",
    "    fold.has_Limb1 = [limb1]\n",
    "    fold.has_Limb2 = [limb2]\n",
    "\n",
    "    return fold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def are_parallel_and_same_direction(v, w):\n",
    "    \"\"\"\n",
    "    Method to check if two vectors are parallel and oriented in the same direction. \n",
    "        It returns True or False.\n",
    "    Parameter:\n",
    "    - v : first vector in the form of np.array([x,y,z])\n",
    "    - w : second vector in the form of np.array([x,y,z])\n",
    "    \"\"\" \n",
    "    # Check if vectors are parallel\n",
    "    if np.allclose(np.cross(v, w), np.zeros_like(v)):\n",
    "        # Check if vectors are in the same direction\n",
    "        dot_product = np.dot(v, w)\n",
    "        if dot_product > 0:\n",
    "            return True  # Vectors are parallel and in the same direction\n",
    "    return False\n",
    "\n",
    "\n",
    "def fold_detector_from_two_parts_of_deformed_stratigraphic_part(stratigraphic_part, part1, part2, physical_space, \n",
    "                                                                knowledge_framework,  part1_rep, part2_rep,\n",
    "                                                                fold = None,\n",
    "                                                                fold_name = None,\n",
    "                                                                force_part1_and_part2 = True, \n",
    "                                                                proposed_fold_axis = None, \n",
    "                                                                ):\n",
    "    \"\"\"\n",
    "    Method to detect folding geometry on two surface parts in the representation of a deformed stratigraphic part.\n",
    "    If the stratigraphic part is not deformed the method will return an error. part1 and part2 could be forced as the two representation \n",
    "    of limb1 and limb2 respectively. A fold axis could be proposed. Only one paramter of these two parameters proposed_fold_axis or force_part1_and_part2\n",
    "    could be given or not, but not both in the same time. if two vectors are parallel and oriented in the same direction. \n",
    "        if found, the method returns : an object of type fold with its properties and relations \n",
    "    Parameter:\n",
    "    - stratigraphic_part : the candidate deformed stratigraphic on which the folding could be detected\n",
    "    - part1 : part1 of the complex_rerpesentation of the stratigraphic_part\n",
    "    - part2 : part2 of the complex_rerpesentation of the stratigraphic_part\n",
    "    - physical_space : the physical space \n",
    "    - knowledge_framework : the knowledge_framework\n",
    "    - coord_labels : coordinates labels ex: [\"X\",\"Y\",\"Z\"] \n",
    "    - fold : the fold object if exist\n",
    "    - fold_name : str for fold name if exist \n",
    "    - force_part1_and_part2 : boolean to force the assignement of part1 and part2 as limb1 and limb2 respectively \n",
    "    - proposed_fold_axis : fold axis if exist in the form of np.array([x,y,z])\n",
    "    \"\"\" \n",
    "    intersection1 = list(set(part1.is_Limb1_Of).intersection(set(part2.is_Limb2_Of)).intersection(set(knowledge_framework().Chevron_Fold.instances())))\n",
    "    intersection2 = list(set(part2.is_Limb1_Of).intersection(set(part2.is_Limb1_Of)).intersection(set(knowledge_framework().Chevron_Fold.instances())))\n",
    "    if len(intersection1) > 0 : \n",
    "        print('Warning: {} and {} already limbs of an existing fold {}. This latter will be returned'.format(part1.name, part1.name,  intersection1[0].name))\n",
    "        return intersection1[0]\n",
    "    if len(intersection2) > 0 : \n",
    "        print('Warning: {} and {} already limbs of an existing fold {}. This latter will be returned'.format(part1.name, part2.name,  intersection2[0].name))\n",
    "        return intersection2[0]\n",
    "    \n",
    "    if proposed_fold_axis != None and force_part1_and_part2 == True:\n",
    "        raise MalissiaBaseError('fold axis could be forced or limbs assignement or both not forced\\\n",
    "                                 but not both forced in the same time')\n",
    "    \n",
    "    if stratigraphic_part.deformed != True:\n",
    "        raise MalissiaBaseError('the stratigraphic part that is possibly a fold must be deformed')\n",
    "    \n",
    "    fold_name = fold_name if fold_name is not None else str('fold_nb{}'.format(len(list(knowledge_framework().Chevron_Fold.instances()))+1))\n",
    "    fold = knowledge_framework().Chevron_Fold(name = fold_name) if fold is None else fold\n",
    "    if knowledge_framework().Fold_Limb not in part1.is_a:\n",
    "        part1.is_a.append(knowledge_framework().Fold_Limb)\n",
    "    if knowledge_framework().Fold_Limb not in part2.is_a:\n",
    "        part2.is_a.append(knowledge_framework().Fold_Limb)\n",
    "    coor_lab = physical_space.coordinate_labels\n",
    "    nodes1 = physical_space.get_object_coordinates( object= part1_rep, kind= \"nodes\")\n",
    "    nodes2 = physical_space.get_object_coordinates( object= part2_rep, kind= \"nodes\")\n",
    "    common_nodes = common_two_nodes_two_planars(nodes1, nodes2)\n",
    "    axis_from_nodes = np.array(common_nodes[0]) - np.array(common_nodes[1])\n",
    "    midpoint = (np.array(common_nodes[0]) + np.array(common_nodes[1])) / 2\n",
    "    side_size = np.linalg.norm(axis_from_nodes)\n",
    "\n",
    "\n",
    "    n1 = physical_space.get_object_coordinates( object= part1_rep, kind= \"normal\")\n",
    "    n2 = physical_space.get_object_coordinates( object= part2_rep, kind= \"normal\")\n",
    "    c1 = physical_space.get_object_coordinates( object= part1_rep, kind= \"center\")\n",
    "    c2 = physical_space.get_object_coordinates( object= part2_rep, kind= \"center\")\n",
    "\n",
    "    fold_axis = compute_fold_axis(n1, c1, n2,  c2)\n",
    "\n",
    "    fold_axis_vector_rep = constructor_vector(knowledge_framework, coor_lab, \n",
    "                                              [float(x) for x in fold_axis], \n",
    "                                              name= \"{}_fold_axis_rep\".format(fold.name))\n",
    "    fold_axis_object = knowledge_framework().Fold_Axis(name = \"{}_fold_axis\".format(fold.name), \n",
    "                                                       has_Representation = [fold_axis_vector_rep])\n",
    "    \n",
    "    if part1 in part2.has_Neighbor or part2  in part1.has_Neighbor or \\\n",
    "                part1_rep in part2_rep.has_Neighbor or part2_rep in part1_rep.has_Neighbor :\n",
    "        \n",
    "        if force_part1_and_part2 == True:\n",
    "            axial_surface = axial_surface_constructor(knowledge_framework = knowledge_framework, \n",
    "                                                      physical_space =physical_space, \n",
    "                                                      fold = fold, limb1_normal= n1, limb2_normal= n2,\n",
    "                                                      fold_axis = fold_axis, \n",
    "                                                      midpoint = midpoint, side_size = side_size, \n",
    "                                                      )\n",
    "            # attach paramters and objects to the fold \n",
    "            \n",
    "            fold.has_Representation = stratigraphic_part.has_Representation\n",
    "            fold.has_Axial_Surface= [axial_surface] \n",
    "            fold.has_Fold_Axis =  [fold_axis_object]\n",
    "            fold.has_Limb1 = [part1]\n",
    "            fold.has_Limb2 = [part2]\n",
    "            return fold\n",
    "        if proposed_fold_axis != None:\n",
    "            proposed_fold_axis = np.array(proposed_fold_axis)\n",
    "            if are_parallel_and_same_direction(fold_axis, proposed_fold_axis):\n",
    "               return fold_detector_from_two_parts_of_deformed_stratigraphic_part(stratigraphic_part = stratigraphic_part, \n",
    "                                                                                  part1 = part1, part2 = part2,\n",
    "                                                                                  part1_rep = part1_rep, part2_rep = part2_rep,\n",
    "                                                                                    physical_space = physical_space, \n",
    "                                                                knowledge_framework = knowledge_framework,                                                                 \n",
    "                                                                fold = fold,                                                \n",
    "                                                                force_part1_and_part2 = True, \n",
    "                                                                proposed_fold_axis = None) \n",
    "            else:\n",
    "                return fold_detector_from_two_parts_of_deformed_stratigraphic_part(stratigraphic_part = stratigraphic_part, \n",
    "                                                                                  part1 = part2, part2 = part1,\n",
    "                                                                                  part1_rep = part1_rep, part2_rep = part2_rep,\n",
    "                                                                                    physical_space = physical_space, \n",
    "                                                                knowledge_framework = knowledge_framework,                                                                  \n",
    "                                                                fold = fold ,                                               \n",
    "                                                                force_part1_and_part2 = True, \n",
    "                                                                proposed_fold_axis = None) \n",
    "            \n",
    "        if proposed_fold_axis == None and force_part1_and_part2 != True:\n",
    "            return fold_detector_from_two_parts_of_deformed_stratigraphic_part(stratigraphic_part = stratigraphic_part, \n",
    "                                                                                  part1 = part1, part2 = part2,\n",
    "                                                                                  part1_rep = part1_rep, part2_rep = part2_rep,\n",
    "                                                                                    physical_space = physical_space, \n",
    "                                                                knowledge_framework = knowledge_framework,\n",
    "                                                                fold = fold ,                                               \n",
    "                                                                force_part1_and_part2 = True, \n",
    "                                                                proposed_fold_axis = None) \n",
    "    else:\n",
    "        return None\n",
    "\n",
    "def extract_neighbors_in_complex_surface(complex_surface):\n",
    "    \n",
    "    \"\"\"\n",
    "    Method to extract neighbors in a complex_surface. It returns a list of pair neighbors if found, else an empty list. \n",
    "    Parameter:\n",
    "    - complex_surface : the cadidate complex_surface\n",
    "    \"\"\" \n",
    "    list_of_neighbors = []\n",
    "    for part in complex_surface.has_Part:\n",
    "        for neighbor in part.has_Neighbor:\n",
    "             pair_of_neighbors = [part, neighbor]\n",
    "             inverse_pair = [neighbor, part]\n",
    "             if pair_of_neighbors not in list_of_neighbors and inverse_pair not in list_of_neighbors:\n",
    "                 list_of_neighbors.append(pair_of_neighbors)\n",
    "    return list_of_neighbors\n",
    "\n",
    "def folding_train_constructor(knowledge_framework, list_of_folds, stratigraphic_part):\n",
    "    return knowledge_framework().Fold_Train(has_Part = list_of_folds, \n",
    "                                               has_Representation = stratigraphic_part.has_Representation)             \n",
    "\n",
    "def folding_train_detector_in_deformed_stratigraphic_part(deformed_stratigraphic_part, physical_space,\n",
    "                                                           knowledge_framework,force_complex_surface = None, ):\n",
    "    \"\"\"\n",
    "    Method to detect mutliple  folding geometry in the representation of a deformed stratigraphic part.\n",
    "        It returns a list of detected fold objects, each fold is associated with its properties and relations. \n",
    "    Parameter:\n",
    "    - deformed_stratigraphic_part : the candidate deformed stratigraphic on which the folding could be detected\n",
    "    - physical_space : the physical space \n",
    "    - knowledge_framework : the knowledge_framework\n",
    "    \"\"\" \n",
    "\n",
    "    complex_representation = deformed_stratigraphic_part.has_Representation[0] if force_complex_surface\\\n",
    "                                         is None else force_complex_surface\n",
    "    if force_complex_surface is None:\n",
    "        if complex_representation.non_planar != True:\n",
    "            raise MalissiaBaseError('problem detected with the representation of the stratigraphic part')\n",
    "    \n",
    "\n",
    "    neighbor_constructor_from_multiple_planars(complex_representation, knowledge_framework, physical_space)\n",
    "    neighbors = extract_neighbors_in_complex_surface(complex_representation)\n",
    "    if len(neighbors) < 2 :\n",
    "        print('Warning no neighbours found in {}, thus no folding train could be detected'.format(complex_representation))\n",
    "        return None\n",
    "    list_of_folds = []\n",
    "    for neighb in neighbors:\n",
    "        neigh1 = neighb[0]\n",
    "        neigh2 = neighb[1]\n",
    "        poss_represented_objects1 = neigh1.is_Representation_Of\n",
    "        poss_represented_objects2 = neigh2.is_Representation_Of\n",
    "        part1 = poss_represented_objects1[0] if len(poss_represented_objects1) == 1 else create_surface_part(knowledge_framework,\n",
    "                                                                        neigh1)\n",
    "        part2 = poss_represented_objects2[0] if len(poss_represented_objects2) == 1 else create_surface_part(knowledge_framework,\n",
    "                                                                        neigh2)\n",
    "\n",
    "        detected_fold = fold_detector_from_two_parts_of_deformed_stratigraphic_part(stratigraphic_part = deformed_stratigraphic_part, \n",
    "                                                    part1 = part1, part2 = part2, part1_rep = neigh1, part2_rep = neigh2,\n",
    "                                                        physical_space= physical_space, knowledge_framework= knowledge_framework)\n",
    "        if detected_fold is not None :\n",
    "            list_of_folds.append(detected_fold)\n",
    "\n",
    "    if len(list_of_folds) < 2 :\n",
    "        return None\n",
    "    else:\n",
    "        return folding_train_constructor(knowledge_framework, list_of_folds, deformed_stratigraphic_part)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Foldss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# conditions\n",
    "def condition_for_fold_detector(knowledge_framework:GeologicalKnowledgeFramework,\n",
    "                                            interpretation_situation:InterpretationSituation, \n",
    "                                            **kargs):\n",
    "    \n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        print(\"Wrong condition for condition_for_fold_detector: knowledge framework\")\n",
    "        return False\n",
    "    if (interpretation_situation is None):\n",
    "        print(\"Wrong condition for condition_for_fold_detector: interpretation situation\")\n",
    "        return False\n",
    "    if  (interpretation_situation.process is None) or (interpretation_situation.process.representation_space is None):\n",
    "        print(\"Wrong condition for condition_for_fold_detector: physical space\")\n",
    "        return False\n",
    "    if  (interpretation_situation.features is None) or (len(interpretation_situation.features) != 1 ):\n",
    "        print(\"Wrong condition for condition_for_fold_detector: features\")\n",
    "        return False\n",
    "    \n",
    "    feature = interpretation_situation.features[0]\n",
    "    rep = feature.has_Representation\n",
    "    if len(rep) != 1 :\n",
    "        print(\"Wrong condition for condition_for_fold_detector: feature representation\")\n",
    "        return False\n",
    "    if not isinstance(rep[0], knowledge_framework().Complex_Surface) or rep[0].non_planar != True:\n",
    "        print(\"Wrong condition for condition_for_fold_detector: feature representation\")\n",
    "        return False\n",
    "    \n",
    "    return True\n",
    "\n",
    "def condition_fold_constructor_from_dipping_anomaly(knowledge_framework:GeologicalKnowledgeFramework,\n",
    "                                            interpretation_situation:InterpretationSituation, \n",
    "                                            **kargs):\n",
    "    \n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        print(\"Wrong condition for condition_fold_constructor_dipping_anomaly: knowledge framework\")\n",
    "        return False\n",
    "    \n",
    "    if (interpretation_situation is None):\n",
    "        print(\"Wrong condition for condition_fold_constructor_dipping_anomaly: interpretation situation\")\n",
    "        return False\n",
    "    if  (interpretation_situation.process is None) or (interpretation_situation.process.representation_space is None):\n",
    "        print(\"Wrong condition for condition_fold_constructor_dipping_anomaly: physical space\")\n",
    "        return False\n",
    "    if  (interpretation_situation.features is None) or (len(interpretation_situation.features) == 0):\n",
    "        print(\"Wrong condition for condition_fold_constructor_dipping_anomaly: features\")\n",
    "        return False\n",
    "    \n",
    "    explained_class = knowledge_framework().DippingStratigraphyAnomaly\n",
    "    explainable_anomalies = knowledge_framework.filter_explainable_features_by_type( interpretation_situation.features, \n",
    "                                                                                   type_of_feature = explained_class)\n",
    "    \n",
    "    if len(explainable_anomalies) == 0 :\n",
    "        print(\"Wrong condition for condition_fold_constructor_dipping_anomaly: no DippingStratigraphyAnomaly\")\n",
    "        return False\n",
    "\n",
    "    return True\n",
    "\n",
    "def condition_fold_constructor_internal_dip_variation_anomaly_two_parts(knowledge_framework:GeologicalKnowledgeFramework,\n",
    "                                            interpretation_situation:InterpretationSituation, \n",
    "                                            **kargs):\n",
    "\n",
    "    # general check\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        print(\"Wrong condition for fold  constructor InternalDipVariationAnomalyTwoParts: knowledge framework\")\n",
    "        return False\n",
    "    \n",
    "    if (interpretation_situation is None):\n",
    "        print(\"Wrong condition for fold constructor InternalDipVariationAnomalyTwoParts: interpretation situation\")\n",
    "        return False\n",
    "    if  (interpretation_situation.process is None) or (interpretation_situation.process.representation_space is None):\n",
    "        print(\"Wrong condition for fold constructor  InternalDipVariationAnomalyTwoParts: physical space\")\n",
    "        return False\n",
    "    if  (interpretation_situation.features is None) or (len(interpretation_situation.features) == 0):\n",
    "        print(\"Wrong condition for fold constructor InternalDipVariationAnomalyTwoParts: features\")\n",
    "        return False\n",
    "    \n",
    "    explained_class = knowledge_framework().InternalDipVariationAnomalyTwoParts\n",
    "    explainable_anomalies = knowledge_framework.filter_explainable_features_by_type( interpretation_situation.features, \n",
    "                                                                                   type_of_feature = explained_class)\n",
    "    \n",
    "    if len(explainable_anomalies) == 0 :\n",
    "        print(\"Wrong condition for condition_fold_constructor_internal_dip_variation_anomaly_two_parts: no InternalDipVariationAnomalyTwoParts\")\n",
    "        return False\n",
    "\n",
    "    # in any other cases\n",
    "    return True\n",
    "\n",
    "def condition_folding_train_detector_from_internal_dip_variation_anomaly_mutli_parts(knowledge_framework:GeologicalKnowledgeFramework,\n",
    "                                            interpretation_situation:InterpretationSituation, \n",
    "                                            **kargs):\n",
    "    # general check\n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        print(\"Wrong condition for fold  constructor InternalDipVariationAnomalyMultiParts: knowledge framework\")\n",
    "        return False\n",
    "    \n",
    "    if (interpretation_situation is None):\n",
    "        print(\"Wrong condition for fold constructor InternalDipVariationAnomalyMultiParts: interpretation situation\")\n",
    "        return False\n",
    "    if  (interpretation_situation.process is None) or (interpretation_situation.process.representation_space is None):\n",
    "        print(\"Wrong condition for fold constructor  InternalDipVariationAnomalyMultiParts: physical space\")\n",
    "        return False\n",
    "    if  (interpretation_situation.features is None) or (len(interpretation_situation.features) == 0):\n",
    "        print(\"Wrong condition for fold constructor InternalDipVariationAnomalyMultiParts: features\")\n",
    "        return False\n",
    "    \n",
    "    # anomaly check\n",
    "    explained_class = knowledge_framework().InternalDipVariationAnomalyMultiParts\n",
    "    explainable_anomalies = knowledge_framework.filter_explainable_features_by_type( interpretation_situation.features, \n",
    "                                                                                   type_of_feature = explained_class)\n",
    "    \n",
    "    if len(explainable_anomalies) == 0 :\n",
    "        print(\"Wrong condition for condition_folding_train_detector_from_internal_dip_variation_anomaly_mutli_parts: no InternalDipVariationAnomalyTwoParts\")\n",
    "        return False\n",
    "\n",
    "    # in any other cases\n",
    "    return True\n",
    "\n",
    "def condition_fold_constructor_dip_variation_anomaly(knowledge_framework:GeologicalKnowledgeFramework,\n",
    "                                            interpretation_situation:InterpretationSituation, \n",
    "                                            **kargs):\n",
    "    \n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        print(\"Wrong condition for fold  constructor: knowledge framework\")\n",
    "        return False\n",
    "    \n",
    "    if (interpretation_situation is None):\n",
    "        print(\"Wrong condition for fold constructor: interpretation situation\")\n",
    "        return False\n",
    "    if  (interpretation_situation.process is None) or (interpretation_situation.process.representation_space is None):\n",
    "        print(\"Wrong condition for fold constructor: physical space\")\n",
    "        return False\n",
    "    if  (interpretation_situation.features is None) or (len(interpretation_situation.features) == 0):\n",
    "        print(\"Wrong condition for fold constructor: features\")\n",
    "        return False\n",
    "    \n",
    "    # anomaly check\n",
    "    explained_class = knowledge_framework().DipVariationAnomaly\n",
    "    explainable_anomalies = knowledge_framework.filter_explainable_features_by_type( interpretation_situation.features, \n",
    "                                                                                   type_of_feature = explained_class)\n",
    "    \n",
    "    if len(explainable_anomalies) == 0 :\n",
    "        print(\"Wrong condition for condition_fold_constructor_dip_variation_anomaly: no DipVariationAnomaly\")\n",
    "        return False\n",
    "\n",
    "    # in any other cases\n",
    "    return True\n",
    "\n",
    "\n",
    "# constructors\n",
    "\n",
    "def fold_constructor_from_dipping_anomaly(interpretation_situation:InterpretationSituation, \n",
    "                                            knowledge_framework = None,\n",
    "                                            **kargs\n",
    "                                        ):\n",
    "    knowledge_framework = knowledge_framework if knowledge_framework is not None else interpretation_situation.knowledge_framework\n",
    "    \n",
    "    physical_space = get_physical_space_in_constructor(interpretation_situation, physical_space= None)\n",
    "    \n",
    "    explained_class = knowledge_framework().DippingStratigraphyAnomaly\n",
    "    explainable_anomalies = knowledge_framework.filter_explainable_features_by_type( interpretation_situation.features, \n",
    "                                                                                   type_of_feature = explained_class)\n",
    "    anomaly = explainable_anomalies[0]\n",
    "    stratigraphic_part = anomaly.is_Related_To[0]\n",
    "    return fold_constructor_one_stratigraphic_part(candidate_stratigraphic_part=stratigraphic_part, \n",
    "                                                   knowledge_framework = knowledge_framework,\n",
    "                                                     physical_space = physical_space, \n",
    "                                                      dipping_anomaly= anomaly )\n",
    "\n",
    "\n",
    "def fold_constructor_from_dip_variation_anomaly(\n",
    "                                            interpretation_situation:InterpretationSituation, \n",
    "                                            knowledge_framework = None,\n",
    "                                            **kargs\n",
    "                                        ):\n",
    "    knowledge_framework = knowledge_framework if knowledge_framework is not None else interpretation_situation.knowledge_framework\n",
    "    physical_space = get_physical_space_in_constructor(interpretation_situation, physical_space= None)\n",
    "    \n",
    "    explained_class = knowledge_framework().DipVariationAnomaly\n",
    "    explainable_anomalies = knowledge_framework.filter_explainable_features_by_type( interpretation_situation.features, \n",
    "                                                                                   type_of_feature = explained_class)\n",
    "    anomaly = explainable_anomalies[0]\n",
    "    stratigraphic_part1 = anomaly.is_Related_To[0]\n",
    "    stratigraphic_part2 = anomaly.is_Related_To[1]\n",
    "    return fold_constructor_from_two_stratigraphic_parts(candidate_stratigraphic_part1 = stratigraphic_part1, \n",
    "                                                         candidate_stratigraphic_part2 = stratigraphic_part2,\n",
    "                                                   knowledge_framework = knowledge_framework,\n",
    "                                                     physical_space = physical_space, \n",
    "                                                      dipping_anomaly= anomaly ) \n",
    "\n",
    "def fold_constructor_from_stratigraphic_part_planar(interpretation_situation:InterpretationSituation, \n",
    "                                            knowledge_framework = None,\n",
    "                                            **kargs\n",
    "                                        ):\n",
    "    knowledge_framework = knowledge_framework if knowledge_framework is not None else interpretation_situation.knowledge_framework\n",
    "\n",
    "    physical_space = get_physical_space_in_constructor(interpretation_situation, physical_space= None)\n",
    "    features = list(interpretation_situation.features)\n",
    "    if len(features) != 1 :\n",
    "            raise MalissiaNotImplementedYet('warning: method for building fold for more than two features is not implemented yet')\n",
    "    \n",
    "    ## todo must add conditions for the stratigraphic_part type and representation\n",
    "\n",
    "    ## todo must add fold detector (returns foldS !)\n",
    "    return fold_constructor_one_stratigraphic_part(features[0], knowledge_framework, physical_space)\n",
    "        \n",
    "def fold_constructor_from_stratigraphic_parts(interpretation_situation:InterpretationSituation, \n",
    "                                            knowledge_framework = None,\n",
    "                                            **kargs\n",
    "                                        ):\n",
    "    knowledge_framework = knowledge_framework if knowledge_framework is not None else interpretation_situation.knowledge_framework\n",
    "    physical_space = get_physical_space_in_constructor(interpretation_situation)\n",
    "    features = list(interpretation_situation.features)\n",
    "    if len(features) != 2  :\n",
    "            raise MalissiaNotImplementedYet('warning: method for building fold for more than two features is not implemented yet')\n",
    "    \n",
    "    ## todo must add conditions for the stratigraphic_part type and representation\n",
    "\n",
    "    ## todo must add fold detector (returns foldS !)\n",
    "\n",
    "    return fold_constructor_from_two_stratigraphic_parts(candidate_stratigraphic_part1= features[0], \n",
    "                                                             candidate_stratigraphic_part2= features[1], \n",
    "                                                             physical_space= physical_space, \n",
    "                                                             knowledge_framework= knowledge_framework)\n",
    "        \n",
    "\n",
    "\n",
    "# detectors\n",
    "\n",
    "\n",
    "\n",
    "def fold_detector_from_internal_dip_variation_anomaly_two_parts(interpretation_situation:InterpretationSituation, \n",
    "                                            knowledge_framework = None,\n",
    "                                            **kargs\n",
    "                                        ):\n",
    "    knowledge_framework = knowledge_framework if knowledge_framework is not None else interpretation_situation.knowledge_framework\n",
    "    physical_space = get_physical_space_in_constructor(interpretation_situation, physical_space= None)\n",
    "    \n",
    "    explained_class = knowledge_framework().InternalDipVariationAnomalyTwoParts\n",
    "    explainable_anomalies = knowledge_framework.filter_explainable_features_by_type( interpretation_situation.features, \n",
    "                                                                                   type_of_feature = explained_class)\n",
    "    anomaly = explainable_anomalies[0]\n",
    "    \n",
    "    stratigraphic_part = anomaly.is_Related_To[0]\n",
    "    stratigraphic_part_rep = stratigraphic_part.has_Representation[0]\n",
    "    part1_rep = stratigraphic_part_rep.has_Part[0]\n",
    "    part2_rep = stratigraphic_part_rep.has_Part[1]\n",
    "    poss_represented_objects1 = part1_rep.is_Representation_Of\n",
    "    poss_represented_objects2 = part2_rep.is_Representation_Of\n",
    "\n",
    "    # creating stratigraphic parts from the complex_surface if they do not exist\n",
    "    part1 = poss_represented_objects1[0] if len(poss_represented_objects1) == 1 else create_surface_part(knowledge_framework,\n",
    "                                                                         part1_rep,)\n",
    "    part2 = poss_represented_objects2[0] if len(poss_represented_objects2) == 1 else create_surface_part(knowledge_framework,\n",
    "                                                                         part2_rep,)\n",
    "\n",
    "    my_fold =  fold_detector_from_two_parts_of_deformed_stratigraphic_part(stratigraphic_part, part1, part2, physical_space, \n",
    "                                                                knowledge_framework,  part1_rep, part2_rep,\n",
    "                                                                fold = None,\n",
    "                                                                fold_name = None,\n",
    "                                                                force_part1_and_part2 = True, \n",
    "                                                                proposed_fold_axis = None, \n",
    "                                                                )\n",
    "    if my_fold is None or not isinstance(my_fold, knowledge_framework().Chevron_Fold):\n",
    "        raise MalissiaBaseError('the created object {} is not a fold'.format(my_fold))\n",
    "    else:\n",
    "        my_fold.explain.append(anomaly)\n",
    "        return my_fold\n",
    "    \n",
    "    \n",
    "def folding_train_detector_from_internal_dip_variation_anomaly_mutli_parts(interpretation_situation:InterpretationSituation, \n",
    "                                            knowledge_framework = None,\n",
    "                                            **kargs\n",
    "                                        ):\n",
    "    knowledge_framework = knowledge_framework if knowledge_framework is not None else interpretation_situation.knowledge_framework\n",
    "    physical_space = get_physical_space_in_constructor(interpretation_situation, physical_space= None)\n",
    "    \n",
    "    explained_class = knowledge_framework().InternalDipVariationAnomalyMultiParts\n",
    "    explainable_anomalies = knowledge_framework.filter_explainable_features_by_type( interpretation_situation.features, \n",
    "                                                                                   type_of_feature = explained_class)\n",
    "    anomaly = explainable_anomalies[0]\n",
    "    stratigraphic_part = anomaly.is_Related_To[0]\n",
    "    my_folding_train = folding_train_detector_in_deformed_stratigraphic_part(deformed_stratigraphic_part= stratigraphic_part,\n",
    "                                                                 physical_space= physical_space,\n",
    "                                                                 knowledge_framework= knowledge_framework)\n",
    "    \n",
    "    if my_folding_train is None or not isinstance(my_folding_train, knowledge_framework().Fold_Train):\n",
    "        raise MalissiaBaseError('the created object {} is not a folding_train'.format(my_folding_train))\n",
    "    else:\n",
    "        my_folding_train.explain.append(anomaly)\n",
    "        return my_folding_train\n",
    "    \n",
    "# extra methods\n",
    "def fold_constructor_from_situation(knowledge_framework:GeologicalKnowledgeFramework,\n",
    "                                    physical_space, # todo: add type hin :PhysicalRepresentationSpace,\n",
    "                                    interpretation_situation:InterpretationSituation, \n",
    "                                    **kargs\n",
    "                                ):\n",
    "    anomalies = interpretation_situation.anomalies\n",
    "    if len(anomalies) > 1:\n",
    "        raise MalissiaBaseError('warning: more than one anomaly in the situation for creating a fold, first one chosen.')\n",
    "    \n",
    "    if len(anomalies) == 1 :\n",
    "        return fold_from_anomalies(knowledge_framework, physical_space, interpretation_situation, anomalies[0])\n",
    "    \n",
    "    if len(anomalies) == 0 :\n",
    "        features = list(interpretation_situation.features)\n",
    "        if len(features) == 0:\n",
    "            raise MalissiaBaseError(\"The situation doesn't contain any selected feature so Fold cannot be created from it.\")\n",
    "        if len(features) > 2:\n",
    "            raise MalissiaNotImplementedYet('warning: method for building fold for more than two features is not implemented yet')\n",
    "        else: \n",
    "            return fold_constructor_from_stratigraphic_parts(knowledge_framework, interpretation_situation)\n",
    "\n",
    "def fold_from_anomalies(knowledge_framework,\n",
    "                        physical_space,\n",
    "                        interpretation_situation,  \n",
    "                        **kargs):\n",
    "    \n",
    "    anomaly = interpretation_situation.anomalies[0]\n",
    "\n",
    "    if not isinstance(anomaly,knowledge_framework().DippingStratigraphyAnomaly):\n",
    "        return fold_constructor_from_dipping_anomaly(knowledge_framework,\n",
    "                                    physical_space,\n",
    "                                    interpretation_situation, anomaly,)\n",
    "    if not isinstance(anomaly,knowledge_framework().DipVariationAnomaly):\n",
    "        return fold_constructor_from_dip_variation_anomaly(knowledge_framework,\n",
    "                                    physical_space,\n",
    "                                    interpretation_situation, anomaly)\n",
    "        \n",
    "\n",
    "    \n",
    "    \n",
    "\n",
    "if \"Chevron_Fold\" in GeologicalKnowledgeFramework.registered_constructors:\n",
    "    del GeologicalKnowledgeFramework.registered_constructors[\"Chevron_Fold\"]\n",
    "\n",
    "\n",
    "GeologicalKnowledgeFramework.register_constructor(\"Chevron_Fold\", \n",
    "                                                  constructor= fold_detector_from_internal_dip_variation_anomaly_two_parts,\n",
    "                                                  condition= condition_fold_constructor_internal_dip_variation_anomaly_two_parts)\n",
    "\n",
    "\n",
    "GeologicalKnowledgeFramework.register_constructor(\"Chevron_Fold\", \n",
    "                                                  constructor= fold_constructor_from_dipping_anomaly,\n",
    "                                                  condition= condition_fold_constructor_from_dipping_anomaly)\n",
    "\n",
    "\n",
    "GeologicalKnowledgeFramework.register_constructor(\"Chevron_Fold\", \n",
    "                                                  constructor= fold_constructor_from_dip_variation_anomaly,\n",
    "                                                  condition= condition_fold_constructor_dip_variation_anomaly)\n",
    "\n",
    "\n",
    "if \"Fold_Train\" in GeologicalKnowledgeFramework.registered_constructors:\n",
    "    del GeologicalKnowledgeFramework.registered_constructors[\"Fold_Train\"]\n",
    "\n",
    "GeologicalKnowledgeFramework.register_constructor(\"Fold_Train\", \n",
    "                                                  constructor= folding_train_detector_from_internal_dip_variation_anomaly_mutli_parts,\n",
    "                                                  condition= condition_folding_train_detector_from_internal_dip_variation_anomaly_mutli_parts)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fold anomalies and evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def missing_explained_objects_anomaly_constructor(knowledge_framework:GeologicalKnowledgeFramework,\n",
    "                                       explaining_object):\n",
    "    \n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        raise MalissiaBaseError(\"Wrong condition for missing_explained_objects : knowledge framework\")\n",
    "    if (explaining_object is None) :\n",
    "        raise MalissiaBaseError(\"Wrong condition for missing_explained_objects : explaining_object is None\")\n",
    "    \n",
    "    anomaly = knowledge_framework().MissingExplainedObjectsAnomaly(is_Related_To = explaining_object)\n",
    "    return anomaly\n",
    "\n",
    "def fold_anomaly_related_to_representation_constructor(knowledge_framework:GeologicalKnowledgeFramework,\n",
    "                                       fold, complex_surface, complex_surface_specific_anomaly):\n",
    "    \n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        raise MalissiaBaseError(\"Wrong condition for missing_explained_objects : knowledge framework\")\n",
    "    if (fold is None) or (complex_surface is None) or (complex_surface_specific_anomaly is None) :\n",
    "        raise MalissiaBaseError(\"Wrong condition for missing_explained_objects : one or multiple anomalic objects (fold, complex_surface, complex_surface_specific_anomaly) are None\")\n",
    "    \n",
    "    anomaly = knowledge_framework().FoldRepresentationAnomaly(is_Related_To_Fold = fold, is_Related_To_Complex_Surface = complex_surface, \n",
    "                                                                   is_Related_To_Anomaly = complex_surface_specific_anomaly)\n",
    "    return anomaly\n",
    "\n",
    "\n",
    "\n",
    "def evaluate_fold_explanation_consistency(fold, knowledge_framework, **kargs):\n",
    "    # todo :  generate coverage anomalies (for points projecting outside of the explaining object)\n",
    "    print('will pass explanation check for folds')\n",
    "    # get representation\n",
    "    rep = fold.has_Representation\n",
    "    if (rep is None) or (len(rep) == 0):\n",
    "        return [ missing_representation_anomaly_constructor(\n",
    "            knowledge_framework= knowledge_framework,\n",
    "            object= fold)]\n",
    "    \n",
    "    if (len(rep) == 1) and (isinstance(rep[0], knowledge_framework().Complex_Surface)):\n",
    "        explained_objects = fold.explain\n",
    "        if len(explained_objects) < 1:\n",
    "            return [missing_explained_objects_anomaly_constructor(knowledge_framework, fold)]\n",
    "        else:\n",
    "            return []\n",
    "    \n",
    "    elif not isinstance(rep[0], knowledge_framework().Complex_Surface):\n",
    "        print('checking error : representations of the fold is not of the type complex_surf')\n",
    "        raise MalissiaNotImplementedYet(\"representations of the fold is not of the type complex_surface\")\n",
    "    else: \n",
    "        print('passing all explanation checks')\n",
    "        return []\n",
    "    \n",
    "\n",
    "def evaluate_fold_internal_consistency(fold, knowledge_framework, physical_space, max_dip= 4, **kargs):\n",
    "    \n",
    "    # get representation\n",
    "    rep = fold.has_Representation\n",
    "    if (rep is None) or (len(rep) == 0):\n",
    "        return [missing_representation_anomaly_constructor(\n",
    "            knowledge_framework= knowledge_framework,\n",
    "            object= fold)]\n",
    "    \n",
    "    complex_surface = rep[0]\n",
    "    # if complex surface has two parts and parallel ==> this surface must be transformed to a simple planar surface\n",
    "    if complex_surface.non_planar != False and complex_surface.non_planar != True:\n",
    "        raise MalissiaBaseError('the complex_surface non_planar_property must be given \"True\" or \"False\"')\n",
    "    if len(complex_surface.has_Part) <2 :\n",
    "        raise MalissiaBaseError('the complex_surface must have at least two parts')\n",
    "    if len(complex_surface.has_Part) >2 and complex_surface.non_planar == False:\n",
    "        raise MalissiaNotImplementedYet('the actual algorithm handle only a non deformed complex_surface of exactly two parts') \n",
    "    \n",
    "    if len(complex_surface.has_Part) ==2 and complex_surface.non_planar == False:\n",
    "        raise MalissiaBaseError('the complex_surface must have that represent a fold must not be planar') \n",
    "    \n",
    "    if len(complex_surface.has_Part) >2 and complex_surface.non_planar == True:\n",
    "    # calcualate the common nodes and shared sides\n",
    "        # check if all shared sides are parallel\n",
    "        if not shared_sides_are_parallel(complex_surface  = complex_surface, knowledge_framework  = knowledge_framework, \n",
    "                                                                                   physical_space =  physical_space):\n",
    "            #he geometry of the complex surface is not conforme because shared sides are not parallel ==> undo last interpetation\n",
    "            return [fold_anomaly_related_to_representation_constructor(knowledge_framework = knowledge_framework,\n",
    "                                       fold = fold, complex_surface =complex_surface, \n",
    "                                       complex_surface_specific_anomaly= shared_side_not_parallel_anomaly(knowledge_framework, complex_surface)),] \n",
    "                \n",
    "        # check if all shared sides in the complex_surface has the same length in the correct allignement\n",
    "        if not shared_sides_are_equal(complex_surface  = complex_surface, knowledge_framework  = knowledge_framework, \n",
    "                                                                                   physical_space =  physical_space):\n",
    "            # raise anomaly that indicates that this complex_surface must be extended ==> look at unmatched neighbor\n",
    "            return [fold_anomaly_related_to_representation_constructor(knowledge_framework = knowledge_framework,\n",
    "                                       fold = fold, complex_surface =complex_surface, \n",
    "                                       complex_surface_specific_anomaly=complex_surface_shared_sides_size_anomaly_constructor(knowledge_framework, complex_surface)),] \n",
    "            \n",
    "        \n",
    "        if not shared_sides_have_uniform_allignement(complex_surface  = complex_surface, knowledge_framework  = knowledge_framework, \n",
    "                                                                                   physical_space =  physical_space):\n",
    "            # raise anomaly that indicates that this complex_surface must be extended ==> look at unmatched neighbor\n",
    "            return [fold_anomaly_related_to_representation_constructor(knowledge_framework = knowledge_framework,\n",
    "                                       fold = fold, complex_surface =complex_surface, \n",
    "                                       complex_surface_specific_anomaly=complex_surface_shared_sides_size_anomaly_constructor(knowledge_framework, complex_surface)),] \n",
    "            \n",
    "        \n",
    "        #check neighbors number and arrangement in the complex_surface\n",
    "        if not check_complex_surface_neighbor_number_and_arrangement(complex_surface  = complex_surface, knowledge_framework  = knowledge_framework, \n",
    "                                                                                   physical_space =  physical_space):\n",
    "            # the geometry of the complex surface is not conforme because the number of neighbors is not adequate with\n",
    "                                                            ## the number of parts (n-1)*2 ==> undo last interpetation\n",
    "            return [fold_anomaly_related_to_representation_constructor(knowledge_framework = knowledge_framework,\n",
    "                                       fold = fold, complex_surface =complex_surface, \n",
    "                                       complex_surface_specific_anomaly=complex_surface_neighbor_number_anomaly(knowledge_framework, complex_surface)),] \n",
    "            \n",
    "         \n",
    "        # check chirality between all neighbors\n",
    "        for pair in extract_neighbors_in_complex_surface(complex_surface) :\n",
    "               if not check_chirality_projection(*pair, knowledge_framework, physical_space ):\n",
    "                   return [fold_anomaly_related_to_representation_constructor(knowledge_framework = knowledge_framework,\n",
    "                                       fold = fold, complex_surface =complex_surface, \n",
    "                                       complex_surface_specific_anomaly=polarity_anomaly_constructor(knowledge_framework, parts = pair)),] \n",
    "    \n",
    "    else:\n",
    "        # if all checks come verified the function will return a an empty list \n",
    "        print('passing all internal checks')\n",
    "        return []\n",
    "\n",
    "\n",
    "GeologicalKnowledgeFramework.register_internal_consistency_evaluator(\"Chevron_Fold\", \n",
    "                                                  method=evaluate_fold_internal_consistency)\n",
    "GeologicalKnowledgeFramework.register_explanation_consistency_evaluator(\"Chevron_Fold\", \n",
    "                                                  method=evaluate_fold_explanation_consistency)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Folding train evluators\n",
    "                          \n",
    "def folding_train_anomaly_related_to_representation_constructor(knowledge_framework:GeologicalKnowledgeFramework,\n",
    "                                       folding_train, complex_surface, complex_surface_specific_anomaly):\n",
    "    \n",
    "    if (knowledge_framework is None) or (knowledge_framework.name != \"mogi\"):\n",
    "        raise MalissiaBaseError(\"Wrong condition for missing_explained_objects : knowledge framework\")\n",
    "    if (folding_train is None) or (complex_surface is None) or (complex_surface_specific_anomaly is None) :\n",
    "        raise MalissiaBaseError(\"Wrong condition for missing_explained_objects : one or multiple anomalic objects (fold, complex_surface, complex_surface_specific_anomaly) are None\")\n",
    "    \n",
    "    anomaly = knowledge_framework().FoldTrainRepresentationAnomaly(is_Related_To_Folding_Train = folding_train, \n",
    "                                                                   is_Related_To_Complex_Surface = complex_surface, \n",
    "                                                                   is_Related_To_Anomaly = complex_surface_specific_anomaly)\n",
    "    return anomaly\n",
    "\n",
    "\n",
    "\n",
    "def evaluate_folding_train_explanation_consistency(folding_train, knowledge_framework, **kargs):\n",
    "    # todo :  generate coverage anomalies (for points projecting outside of the explaining object)\n",
    "    print('will pass explanation check for folds')\n",
    "    # get representation\n",
    "    rep = folding_train.has_Representation\n",
    "    if (rep is None) or (len(rep) == 0):\n",
    "        return [ missing_representation_anomaly_constructor(\n",
    "            knowledge_framework= knowledge_framework,\n",
    "            object= folding_train)]\n",
    "    \n",
    "    if (len(rep) == 1) and (isinstance(rep[0], knowledge_framework().Complex_Surface)):\n",
    "        explained_objects = folding_train.explain\n",
    "        if len(explained_objects) < 1:\n",
    "            return [missing_explained_objects_anomaly_constructor(knowledge_framework, folding_train)]\n",
    "        else:\n",
    "            return []\n",
    "    \n",
    "    elif not isinstance(rep[0], knowledge_framework().Complex_Surface):\n",
    "        print('checking error : representations of the fold is not of the type complex_surf')\n",
    "        raise MalissiaNotImplementedYet(\"representations of the fold is not of the type complex_surface\")\n",
    "    else: \n",
    "        print('passing all explanation checks')\n",
    "        return []\n",
    "    \n",
    "\n",
    "def evaluate_folding_train_internal_consistency(folding_train, knowledge_framework, physical_space, max_dip= 4, **kargs):\n",
    "    \n",
    "    # get representation\n",
    "    rep = folding_train.has_Representation\n",
    "    if (rep is None) or (len(rep) == 0):\n",
    "        return [missing_representation_anomaly_constructor(\n",
    "            knowledge_framework= knowledge_framework,\n",
    "            object= folding_train)]\n",
    "    \n",
    "    complex_surface = rep[0]\n",
    "    # if complex surface has two parts and parallel ==> this surface must be transformed to a simple planar surface\n",
    "    if complex_surface.non_planar != False and complex_surface.non_planar != True:\n",
    "        raise MalissiaBaseError('the complex_surface non_planar_property must be given \"True\" or \"False\"')\n",
    "    if len(complex_surface.has_Part) <2 :\n",
    "        raise MalissiaBaseError('the complex_surface must have at least two parts')\n",
    "    if len(complex_surface.has_Part) >2 and complex_surface.non_planar == False:\n",
    "        raise MalissiaNotImplementedYet('the actual algorithm handle only a non deformed complex_surface of exactly two parts') \n",
    "    \n",
    "    if len(complex_surface.has_Part) ==2 and complex_surface.non_planar == False:\n",
    "        raise MalissiaBaseError('the complex_surface must have that represent a fold must not be planar') \n",
    "    \n",
    "    if len(complex_surface.has_Part) >2 and complex_surface.non_planar == True:\n",
    "    # calcualate the common nodes and shared sides\n",
    "        # check if all shared sides are parallel\n",
    "        if not shared_sides_are_parallel(complex_surface  = complex_surface, knowledge_framework  = knowledge_framework, \n",
    "                                                                                   physical_space =  physical_space):\n",
    "            #he geometry of the complex surface is not conforme because shared sides are not parallel ==> undo last interpetation\n",
    "            return [folding_train_anomaly_related_to_representation_constructor(knowledge_framework = knowledge_framework,\n",
    "                                       folding_train = folding_train, complex_surface =complex_surface, \n",
    "                                       complex_surface_specific_anomaly=shared_side_not_parallel_anomaly(knowledge_framework, complex_surface)),] \n",
    "                \n",
    "        # check if all shared sides in the complex_surface has the same length in the correct allignement\n",
    "        if not shared_sides_are_equal(complex_surface  = complex_surface,knowledge_framework  = knowledge_framework, \n",
    "                                                                                   physical_space =  physical_space):\n",
    "            # raise anomaly that indicates that this complex_surface must be extended ==> look at unmatched neighbor\n",
    "            return [folding_train_anomaly_related_to_representation_constructor(knowledge_framework = knowledge_framework,\n",
    "                                       folding_train = folding_train, complex_surface =complex_surface, \n",
    "                                       complex_surface_specific_anomaly=complex_surface_shared_sides_size_anomaly_constructor(knowledge_framework, complex_surface)),] \n",
    "            \n",
    "        \n",
    "        if not shared_sides_have_uniform_allignement(complex_surface  = complex_surface, knowledge_framework  = knowledge_framework, \n",
    "                                                                                   physical_space =  physical_space):\n",
    "            # raise anomaly that indicates that this complex_surface must be extended ==> look at unmatched neighbor\n",
    "            \n",
    "            return [folding_train_anomaly_related_to_representation_constructor(knowledge_framework = knowledge_framework,\n",
    "                                       folding_train = folding_train, complex_surface =complex_surface, \n",
    "                                       complex_surface_specific_anomaly=complex_surface_shared_sides_size_anomaly_constructor(knowledge_framework, complex_surface)),] \n",
    "            \n",
    "        #check neighbors number and arrangement in the complex_surface\n",
    "        if not check_complex_surface_neighbor_number_and_arrangement(complex_surface  = complex_surface, knowledge_framework  = knowledge_framework, \n",
    "                                                                                   physical_space =  physical_space):\n",
    "            # the geometry of the complex surface is not conforme because the number of neighbors is not adequate with\n",
    "                                                            ## the number of parts (n-1)*2 ==> undo last interpetation\n",
    "            return [folding_train_anomaly_related_to_representation_constructor(knowledge_framework = knowledge_framework,\n",
    "                                       folding_train = folding_train, complex_surface =complex_surface, \n",
    "                                       complex_surface_specific_anomaly=complex_surface_neighbor_number_anomaly(knowledge_framework, complex_surface)),] \n",
    "        \n",
    "         \n",
    "        # check chirality between all neighbors\n",
    "        for pair in extract_neighbors_in_complex_surface(complex_surface) :\n",
    "               if not check_chirality_projection(*pair, knowledge_framework, physical_space ):\n",
    "                   return [folding_train_anomaly_related_to_representation_constructor(knowledge_framework = knowledge_framework,\n",
    "                                       folding_train = folding_train, complex_surface =complex_surface, \n",
    "                                       complex_surface_specific_anomaly=polarity_anomaly_constructor(knowledge_framework, parts = pair)),] \n",
    "        return []\n",
    "    else:\n",
    "        # if all checks come verified the function will return a an empty list \n",
    "        return []\n",
    "\n",
    "\n",
    "GeologicalKnowledgeFramework.register_internal_consistency_evaluator(\"Fold_Train\", \n",
    "                                                  method=evaluate_folding_train_internal_consistency)\n",
    "GeologicalKnowledgeFramework.register_explanation_consistency_evaluator(\"Fold_Train\", \n",
    "                                                  method=evaluate_folding_train_explanation_consistency)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Complex Surfaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "# compute and construct\n",
    "\n",
    "def list_coords_to_list_nodes(list_of_coord, knowledge_framewrok, coord_labels):\n",
    "    return [create_nodes_from_coords(knowledge_framewrok, coord_i, \n",
    "                                     coord_labels) for coord_i in list_of_coord]\n",
    "\n",
    "def list_of_planars_from_nodes(list_nodes, knowledge_framework):\n",
    "    list_of_planars = []\n",
    "    for node_i in list_nodes:\n",
    "        plan_i = create_planar_surface(knowledge_framework, node_i)\n",
    "        set_center(knowledge_framework, plan_i)\n",
    "        set_attitude(knowledge_framework, plan_i)\n",
    "        list_of_planars.append(plan_i)\n",
    "    return list_of_planars\n",
    "    \n",
    "def list_of_parts_from_nodes(list_of_planars, knowledge_framework):\n",
    "    return [create_surface_part(knowledge_framework, node_i) for node_i in list_of_planars]\n",
    "\n",
    "\n",
    "def complex_surface_parts_annexation(complex_surface, new_parts, \n",
    "                                     change_name_of_new_parts = False):\n",
    "    \"\"\"Method to annexe parts to an existing complex_surface . It returns the complex_surface after including the new parts.\n",
    "    Parameter:\n",
    "    - complex_surface:  the candidate complex_surface\n",
    "    - new_parts:  a list of parts to be included\n",
    "    - change_name_of_new_parts : a boolean by default is False, to force changing if yes the name of the new parts\"\"\"  \n",
    "    if change_name_of_new_parts is False: \n",
    "        for part in new_parts:\n",
    "            if part not in complex_surface.has_Part:\n",
    "                complex_surface.has_Part.append(part)\n",
    "        return complex_surface\n",
    "    else:\n",
    "        nb_of_existing_parts = len(complex_surface.has_Part)\n",
    "        for part in new_parts:\n",
    "            if part not in complex_surface.has_Part:\n",
    "                nb_of_existing_parts += 1\n",
    "                part.name =  'part_{}_of_{}'.format(nb_of_existing_parts, complex_surface.name)\n",
    "                complex_surface.has_Part.append(part)\n",
    "        return complex_surface    \n",
    "\n",
    "def find_equivalent_list(main_list, list_of_lists, tolerance=0.5):\n",
    "    if not isinstance(main_list, list):\n",
    "        raise MalissiaBaseError('main_list {} is not of type list'.format(main_list))\n",
    "    for sublist in list_of_lists:\n",
    "        if all(abs(a - b) <= tolerance for a, b in zip(main_list, sublist)):\n",
    "            return sublist\n",
    "    return None\n",
    "\n",
    "\n",
    "def are_sets_close(set1, set2, tolerance = 0.3):\n",
    "    # Check if sets have the same length\n",
    "    if len(set1) != len(set2):\n",
    "        return False\n",
    "\n",
    "    # Iterate through elements and compare with tolerance\n",
    "    for el1, el2 in zip(set1, set2):\n",
    "        if abs(el1 - el2) > tolerance:\n",
    "            return False\n",
    "\n",
    "    return True\n",
    "\n",
    "\n",
    "\n",
    "def neighbor_constructor_from_two_planars(part1, part2, \n",
    "                                          knowledge_framework,  physical_space,\n",
    "                                          tolerance = 0.3, \n",
    "                                          complex_surface = None,\n",
    "                                            same_complex_surface_condition = True):\n",
    "    \n",
    "    \"\"\"Method to constrtuct neighbors of two parts in a complex_surface if they have exactly two shared nodes 'nodes with the same coordaintes'.\n",
    "     . It assign the neighbors if the conditions are met but it does not return anything .\n",
    "    Parameter:\n",
    "    - part1 : first plane \n",
    "    - part2 : second plane \n",
    "    - physical_space : the physical_space\n",
    "    - knowledge_framework = the \n",
    "    - tolerance = a tolerance value to define the distance at which two nodes are considered as superposed 'the instruction to use  \n",
    "    - complex_surface = the complex_surface if it exists, or the method will generate new one\n",
    "    - same_complex_surface_condition = by default True, a boolean to ensure that the two parts to be neighbors must be part of the same complex_surface\"\"\"  \n",
    "    \n",
    "    if same_complex_surface_condition == True:\n",
    "        if complex_surface not in list(set(part2.is_Part_Of).intersection(part1.is_Part_Of)):\n",
    "            raise MalissiaBaseError('the {} and {} are not in the same complex_surface and \\\n",
    "                                    same_complex_surface_condition is enforced \"True\"'.format(part1, part2))\n",
    "    \n",
    "    \n",
    "    commons = {}\n",
    "    com_init = 1\n",
    "    for no_i in part1.has_Representation:\n",
    "        val_i = physical_space.get_object_coordinates(no_i,'nodes')[0]\n",
    "        for idx_ii, no_ii in enumerate(part2.has_Representation):\n",
    "            val_ii = physical_space.get_object_coordinates(no_ii,'nodes')[0]\n",
    "            if are_sets_close(set(val_i), set(val_ii), tolerance) :\n",
    "                commons['common_node{}'.format(com_init)] = [no_i, no_ii, idx_ii]\n",
    "                com_init += 1\n",
    "    \n",
    "    #common_nodes = [node_i for node_i in nodes1 if node_i in nodes2] # if an error here node_i should be also a list\n",
    "    common_nodes_nb = len(commons)\n",
    "    if common_nodes_nb == 3 or common_nodes_nb == 4:\n",
    "        print(part1, part2)\n",
    "        raise MalissiaBaseError('parts to be neighbors must not be superposed')\n",
    "    if common_nodes_nb == 2:\n",
    "        if part2 not in part1.has_Neighbor:\n",
    "            part1.has_Neighbor.append(part2)\n",
    "        if part1 not in part2.has_Neighbor: # this block is redundant as the relation must be symmetric\n",
    "            part2.has_Neighbor.append(part1)\n",
    "        \n",
    "\n",
    "        intersection_set = set(part2.has_Shared_Side).intersection(part1.has_Shared_Side)\n",
    "        if not intersection_set:\n",
    "            n1_coor = physical_space.get_object_coordinates( object= commons['common_node1'][0], \n",
    "                                                            kind= \"nodes\")[0]\n",
    "            n2_coor = physical_space.get_object_coordinates( object= commons['common_node2'][0], \n",
    "                                                            kind= \"nodes\")[0]\n",
    "            side_size = float(np.linalg.norm(np.array(n1_coor)-np.array(n2_coor)))\n",
    "\n",
    "            shared_side = knowledge_framework().Side(has_End_Points = [commons['common_node1'][0], \n",
    "                                                                       commons['common_node2'][0]], \n",
    "                                                                        size = [side_size])  \n",
    "            part1.has_Shared_Side.append(shared_side)\n",
    "            part2.has_Shared_Side.append(shared_side)\n",
    "        \n",
    "        \n",
    "\n",
    "        # change commonde nodes in the part2.rep and in the pertinent nodes by nodes of part1 \n",
    "        part2.has_Representation[commons['common_node1'][2]] = commons['common_node1'][0]\n",
    "        part2.has_Representation[commons['common_node2'][2]] = commons['common_node2'][0]\n",
    "        for n in range(0,4):\n",
    "            node_i = getattr(part2, 'has_Node{}'.format(n))\n",
    "            if commons['common_node1'][1] in node_i :\n",
    "                setattr(part2, 'has_Node{}'.format(n), [commons['common_node1'][0]])\n",
    "            elif commons['common_node2'][1] in node_i :\n",
    "                setattr(part2, 'has_Node{}'.format(n), [commons['common_node2'][0]])\n",
    "                \n",
    "\n",
    "            \n",
    "\n",
    "    # if there is no neighbor, check for possible unmatched neighbors that share an unmatched side\n",
    "    else:\n",
    "        nodes1 = (physical_space.get_object_coordinates( object= part1, kind= \"nodes\")).tolist()\n",
    "        nodes2 = (physical_space.get_object_coordinates( object= part2, kind= \"nodes\")).tolist()\n",
    "        reference_sides = [[nodes1[0],nodes1[1]],\n",
    "                            [nodes1[1],nodes1[2]],\n",
    "                             [nodes1[2],nodes1[3]],\n",
    "                            [nodes1[3],nodes1[0]]]\n",
    "        part2_sides =  [[nodes2[0],nodes2[1]],\n",
    "                            [nodes2[1],nodes2[2]],\n",
    "                             [nodes2[2],nodes2[3]],\n",
    "                            [nodes2[3],nodes2[0]]]\n",
    "\n",
    "        for ref_side in reference_sides:\n",
    "            ref_vec = np.array(ref_side[0])-np.array(ref_side[1])\n",
    "            for side in part2_sides:\n",
    "                vec_side = np.array(side[0])-np.array(side[1])\n",
    "                parallel = are_vectors_parallel(vec_side, ref_vec)\n",
    "                if parallel: \n",
    "                    projec_start_side = compute_point_projection_onto_line(side[0], ref_side[0], ref_vec )\n",
    "                    projec_end_side = compute_point_projection_onto_line(side[1], ref_side[0], ref_vec )\n",
    "                    mag_projec_start_side = np.linalg.norm(np.array(side[0])-np.array(projec_start_side))\n",
    "                    mag_projec_end_side = np.linalg.norm(np.array(side[1])-np.array(projec_end_side))\n",
    "\n",
    "                    #print(projec_start_side, projec_end_side, mag_projec_start_side, mag_projec_end_side)\n",
    "\n",
    "                    if mag_projec_end_side == 0 and mag_projec_start_side == 0 : \n",
    "                        \n",
    "                        if part1 not in part2.has_Unmatched_Neighbor and  part2 not in part1.has_Unmatched_Neighbor:\n",
    "                            # assuming that if part1 is already in unmatched neighbor of part2 or the inverse, they already have unmatched shared sides\n",
    "                            part2.has_Unmatched_Neighbor.append(part1)\n",
    "                            part1.has_Unmatched_Neighbor.append(part2)\n",
    "                            \n",
    "                            share_sides_nb = len(knowledge_framework().Side.instances())\n",
    "                            point_nb =  len(knowledge_framework().Point.instances())\n",
    "\n",
    "                            point_0_part1_side = constructor_point(knowledge_framework, physical_space.coordinate_labels,\n",
    "                                                [float(x) for x in ref_side[0]], name=\"end_point_nb_{}\".format(point_nb+1))\n",
    "                            point_1_part1_side = constructor_point(knowledge_framework, physical_space.coordinate_labels,\n",
    "                                                [float(x) for x in ref_side[1]], name=\"end_point_nb_{}\".format(point_nb+2))\n",
    "                            share_sides_name1 = str('side_nb_{}'.format(share_sides_nb+1))\n",
    "                            side_size1 = float(np.linalg.norm(np.array(ref_side[0])-np.array(ref_side[1])))\n",
    "                            shared_side_1 = knowledge_framework().Side(name = share_sides_name1, has_End_Points = [point_0_part1_side,\n",
    "                                                                                                                point_1_part1_side],\n",
    "                                                                                                                size = [side_size1])  \n",
    "                            if shared_side_1 not in part1.has_Unmatched_Shared_Side :\n",
    "                                part1.has_Unmatched_Shared_Side.append(shared_side_1)\n",
    "\n",
    "                            point_0_part2_side = constructor_point(knowledge_framework, physical_space.coordinate_labels,\n",
    "                                                [float(x) for x in side[0]], name=\"end_point_nb_{}\".format(point_nb+3))\n",
    "                            point_1_part2_side = constructor_point(knowledge_framework, physical_space.coordinate_labels,\n",
    "                                                [float(x) for x in side[1]], name=\"end_point_nb_{}\".format(point_nb+4))\n",
    "                            share_sides_name2 = str('side_nb_{}'.format(share_sides_nb+2))\n",
    "                            side_size2 = float(np.linalg.norm(np.array(side[0])-np.array(side[1])))\n",
    "                            shared_side_2 = knowledge_framework().Side(name = share_sides_name2, has_End_Points = [point_0_part2_side,\n",
    "                                                                                                                point_1_part2_side],\n",
    "                                                                                                            size = [side_size2])  \n",
    "                            if  shared_side_2 not in  part2.has_Unmatched_Shared_Side:\n",
    "                                part2.has_Unmatched_Shared_Side.append(shared_side_2)\n",
    "\n",
    "                            shared_side_1.has_Corresponding_Part = [part2]\n",
    "                            shared_side_2.has_Corresponding_Part = [part1]\n",
    "                            break\n",
    "                        else:\n",
    "                            break\n",
    "            else:\n",
    "                continue\n",
    "            break\n",
    "            \n",
    "    \n",
    "def neighbor_constructor_from_multiple_planars(complex_surface, \n",
    "                                                knowledge_framework,\n",
    "                                                physical_space,\n",
    "                                                tolerance = 0.1):\n",
    "    \n",
    "    \"\"\"\n",
    "    Method to constrtuct neighbors of multiple parts in a complex_surface if they have exactly two shared nodes 'nodes with the same coordaintes'.\n",
    "     . It assign the neighbors if the conditions are met but it does not return anything.\n",
    "    Parameter:\n",
    "    - complex_surface:  the candidate complex_surface\n",
    "    - physical_space:  the physical_space\n",
    "    - knowledge_framework : the knowledge_framework\n",
    "    \"\"\"  \n",
    "    \n",
    "    list_of_parts = complex_surface.has_Part\n",
    "    pairs = compute_pairs_of_surfaces_in_complex_surface(list_of_parts)\n",
    "    for pair in pairs:\n",
    "        if pair[0]  in pair[1].has_Neighbor or pair[1] in pair[0].has_Neighbor :\n",
    "            pass\n",
    "        else:\n",
    "            neighbor_constructor_from_two_planars(pair[0], pair[1], \n",
    "                                                  knowledge_framework = knowledge_framework, \n",
    "                                                  physical_space = physical_space ,\n",
    "                                            tolerance = tolerance, complex_surface = complex_surface, \n",
    "                                            same_complex_surface_condition = True)\n",
    "\n",
    "def compute_pairs_of_surfaces_in_complex_surface(list_of_parts):\n",
    "    \"\"\"\n",
    "    Method to compute possible pairs combinations in a list of parts. It returns ta list of combinations.\n",
    "    Parameter:\n",
    "    - list_of_parts:  list of parts\n",
    "    \"\"\"  \n",
    "    return list(itertools.combinations(list_of_parts, 2))\n",
    "\n",
    "def compute_complex_surface_extreme_surfaces(knowledge_framework,\n",
    "                                          complex_surface, return_none = False):\n",
    "    \n",
    "    \"\"\"Method to detect the two extreme surfaces of a complex surface based on the number of neighbors of each part of it \n",
    "    (must be one neighbor for the each extremete face)\"\"\"\n",
    "    list_of_parts = complex_surface.has_Part\n",
    "    if knowledge_framework().Complex_Surface not in complex_surface.is_instance_of:\n",
    "        if return_none == True:\n",
    "            return None\n",
    "        raise MalissiaBaseError('the introduced object is not a complex surface')\n",
    "    elif len(list_of_parts) < 2 :\n",
    "        if return_none == True:\n",
    "            return None\n",
    "        raise MalissiaBaseError('the complex surface has less then two parts')\n",
    "    \n",
    "    elif len(list_of_parts) == 2:\n",
    "         if complex_surface.has_Part[0] in  complex_surface.has_Part[1].has_Neighbor or \\\n",
    "                complex_surface.has_Part[1] in  complex_surface.has_Part[0].has_Neighbor:\n",
    "             return [complex_surface.has_Part[0], complex_surface.has_Part[1]]\n",
    "         else:\n",
    "             print('Warning: the complex_surface {} has two parts but they are not extreme faces, check neighborhood properties'.format(complex_surface.name))\n",
    "             return None \n",
    "    else:\n",
    "        extreme_surfaces = [part for part in list_of_parts if \\\n",
    "                            len(set(part.has_Neighbor).intersection(set(list_of_parts))) == 1]\n",
    "        print(len(extreme_surfaces))\n",
    "        if len(extreme_surfaces) != 2 :\n",
    "            if return_none == True:\n",
    "                return None\n",
    "            raise MalissiaBaseError('the complex_surface has a problem with geometry \"multiple or less than two extreme surfaces\"')\n",
    "        else:\n",
    "            return extreme_surfaces\n",
    "        \n",
    "def compute_extremeties_from_two_extreme_surfaces(extreme_surfaces, physical_space):\n",
    "    \"\"\"\n",
    "    Method to compute 4 nodes that represent extremeties of an existing complex_surface. It returns a list containing two pairs of nodes.\n",
    "    Parameter:\n",
    "    - extreme_surfaces:  a list of exactly two etreme faces of a complex_surface\n",
    "    - physical_space:  the physical_space\n",
    "    \"\"\"  \n",
    "    nodes_of_part1 = (physical_space.get_object_coordinates( object= extreme_surfaces[0],\n",
    "                                                                kind= \"nodes\")).tolist()\n",
    "    part1_neighbor = extreme_surfaces[0].has_Neighbor[0]\n",
    "    nodes_of_part1_neighbor = (physical_space.get_object_coordinates( object= part1_neighbor, \n",
    "                                                                        kind= \"nodes\")).tolist()\n",
    "    # to use tolerance it is possible to use the distance between two points that they could be consdired as one\n",
    "    uncommon_nodes_nb1 = [node_i for node_i in nodes_of_part1 if node_i not in nodes_of_part1_neighbor]\n",
    "    if  len(uncommon_nodes_nb1) != 2:\n",
    "        raise MalissiaBaseError('part1 has more than 2 uncommon nodes with its neighbor')\n",
    "    else:\n",
    "        extremities_0_1 = uncommon_nodes_nb1\n",
    "\n",
    "    nodes_of_part2 = (physical_space.get_object_coordinates( object= extreme_surfaces[1],\n",
    "                                                                kind= \"nodes\")).tolist()\n",
    "    part2_neighbor = extreme_surfaces[1].has_Neighbor[0]\n",
    "    nodes_of_part2_neighbor = (physical_space.get_object_coordinates( object= part2_neighbor, \n",
    "                                                                        kind= \"nodes\")).tolist()\n",
    "    # to use tolerance it is possible to use the distance between two points that they could be consdired as one\n",
    "    uncommon_nodes_nb2 = [node_i for node_i in nodes_of_part2 if node_i not in nodes_of_part2_neighbor]\n",
    "\n",
    "    if  len(uncommon_nodes_nb2) != 2:\n",
    "        raise MalissiaBaseError('part2 has more than 2 uncommon nodes with its neighbor')\n",
    "    else:\n",
    "        extremities_2_3 = uncommon_nodes_nb2\n",
    "    return [extremities_0_1, extremities_2_3]\n",
    "        \n",
    "\n",
    "def complex_surface_two_planars_constructor(knowledge_framework, physical_space,\n",
    "                                          complex_surface, nodes1_temp, \n",
    "                                          nodes2_temp, \n",
    "                                          side_size = None,  force_non_planar_sign = None, \n",
    "                                          proposed_nodes1 = None,\n",
    "                                          proposed_nodes2 = None, \n",
    "                                          forced_p2_v3 = None, \n",
    "                                          forced_p2_v2 = None, \n",
    "                                          forced_p1_v3 = None, \n",
    "                                          forced_p1_v2 = None, ):\n",
    "    \"\"\"\n",
    "    Method to construct two parts if complex surface and assign them to it. It returns the constructed complex_surface.\n",
    "    Parameter:\n",
    "    - knowledge_framework : the knowledge_framework\n",
    "    - physical_space : the physical_space\n",
    "    - complex_surface:  the candidate complex_surface\n",
    "    - nodes1_temp:  temporary np.array of part1 nodes\n",
    "    - nodes2_temp:  temporary np.array of part2 nodes\n",
    "    - side_size : a side size of it exist\n",
    "    - force_non_planar_sign : boolean to force the sign of non_planar dataproperty of the complex_surface\n",
    "    \"\"\"      \n",
    "    nb_nodes = len(knowledge_framework().Point.instances())\n",
    "    coord_labels = physical_space.coordinate_labels\n",
    "\n",
    "    if proposed_nodes1 is None :\n",
    "        nodes1 = [\n",
    "            constructor_point(knowledge_framework, coord_labels,[float(x) for x in nodes1_temp[0]], name=\"Node_{}\".format(nb_nodes+1)),\n",
    "            constructor_point(knowledge_framework, coord_labels,[float(x) for x in nodes1_temp[1]], name=\"Node_{}\".format(nb_nodes+2)),\n",
    "            constructor_point(knowledge_framework, coord_labels,[float(x) for x in nodes1_temp[2]], name=\"Node_{}\".format(nb_nodes+3)),\n",
    "            constructor_point(knowledge_framework, coord_labels,[float(x) for x in nodes1_temp[3]], name=\"Node_{}\".format(nb_nodes+4))\n",
    "            ]\n",
    "    else: nodes1 = proposed_nodes1\n",
    "         \n",
    "    if proposed_nodes2 is None :\n",
    "        nodes2 = [\n",
    "            constructor_point(knowledge_framework, coord_labels,[float(x) for x in nodes2_temp[0]], name=\"Node_{}\".format(nb_nodes+5)),\n",
    "            constructor_point(knowledge_framework, coord_labels,[float(x) for x in nodes2_temp[1]], name=\"Node_{}\".format(nb_nodes+6)),\n",
    "            constructor_point(knowledge_framework, coord_labels,[float(x) for x in nodes2_temp[2]], name=\"Node_{}\".format(nb_nodes+7)),\n",
    "            constructor_point(knowledge_framework, coord_labels,[float(x) for x in nodes2_temp[3]], name=\"Node_{}\".format(nb_nodes+8))\n",
    "            ]\n",
    "    else: nodes2 = proposed_nodes2\n",
    "\n",
    "    nodes2[0] = nodes1[1]\n",
    "    nodes2[1] = nodes1[0]\n",
    "\n",
    "    nodes1[2] =  forced_p1_v2 if forced_p1_v2 is not  None else nodes1[2]\n",
    "    nodes1[3] =  forced_p1_v3 if forced_p1_v3 is not  None else nodes1[3]\n",
    "\n",
    "    nodes2[2] =  forced_p2_v2 if forced_p2_v2 is not  None else nodes2[2]\n",
    "    nodes2[3] =  forced_p2_v3 if forced_p2_v3 is not  None else nodes2[3]\n",
    "    \n",
    "     \n",
    "\n",
    "\n",
    "    nb_parts = len(knowledge_framework().Planar_Surface.instances())\n",
    "    \n",
    "    new_part1 = constructor_planar_surface_from_nodes(knowledge_framework, \n",
    "                                                        nodes1, name= 'part_nb{}'.format(nb_parts+1))\n",
    "\n",
    "    new_part2 = constructor_planar_surface_from_nodes(knowledge_framework, \n",
    "                                                        nodes2, name= 'part_nb{}'.format(nb_parts+2))\n",
    "\n",
    "    share_sides_nb = len(knowledge_framework().Side.instances())+1\n",
    "    point_nb =  len(knowledge_framework().Point.instances())+1\n",
    "\n",
    "    #end_point_0 = constructor_point(knowledge_framework, coord_labels, [float(x) for x in nodes2_temp[0]], name=\"end_point_nb_{}\".format(point_nb))\n",
    "    #end_point_1 = constructor_point(knowledge_framework, coord_labels, [float(x) for x in nodes2_temp[1]], name=\"end_point_nb_{}\".format(point_nb+1))\n",
    "    end_point_0 = new_part2.has_Node0[0]\n",
    "    end_point_1 = new_part2.has_Node1[0]\n",
    "    share_sides_name = str('shared_side_nb_{}'.format(share_sides_nb))\n",
    "    side_size = float(np.linalg.norm(np.array(nodes2_temp[0])-np.array(nodes2_temp[1]))) # if side_size is None else float(side_size)\n",
    "    shared_side = knowledge_framework().Side(name = share_sides_name, has_End_Points = [end_point_0, end_point_1], \n",
    "                                              size = [side_size])  \n",
    "    \n",
    "    new_part1.has_Shared_Side.append(shared_side)\n",
    "    new_part2.has_Shared_Side.append(shared_side)\n",
    "    \n",
    "    complex_surface.has_Part.extend([new_part1, new_part2])\n",
    "    new_part1.has_Neighbor = [new_part2]\n",
    "    new_part2.has_Neighbor = [new_part1] # this should be deleted because the relation is symmetrical\n",
    "    if type(force_non_planar_sign) is bool:\n",
    "        complex_surface.non_planar = force_non_planar_sign     \n",
    "    return complex_surface\n",
    "    \n",
    "def compute_center_nodes(nodes):\n",
    "\n",
    "    center_coord = np.mean(nodes,axis=0)\n",
    "    return center_coord\n",
    "\n",
    "def compute_complex_surface_two_planars(planar1, planar2, \n",
    "                                knowledge_framework, physical_space, \n",
    "                                complex_surface = None, complex_surface_name = None, \n",
    "                                force_projection_of_part_1_extremeties_on_axis = False, \n",
    "                                axis_1 = None, axis_1_origin = None,\n",
    "                                force_projection_of_part_2_extremeties_on_axis = False, \n",
    "                                axis_2 = None, axis_2_origin = None, \n",
    "                                tolerance_angle_parallel = 3, tolerance_angle_coplan = 3,\n",
    "                                forced_p2_v3 = None, \n",
    "                                          forced_p2_v2 = None, \n",
    "                                          forced_p1_v3 = None, \n",
    "                                          forced_p1_v2 = None, tolerance = 0.1):\n",
    "    \"\"\"\n",
    "    Method to compute a complex_surface from two planars. It returns a complex_surface. \n",
    "    It could use an existing complex_surface and add new parts to it.\n",
    "    if the surfaces are parellel, they must be on the same plane and have the same polarity of the method will raise an error and \n",
    "        assigning non_planar quality as false. If they meet these conditions the method generate a complex_surface with new parts.\n",
    "    If the surfaces are not parallel, the method will create a complex_surface by computing an intersection line, direction and \n",
    "        calculating nodes and assining non_planar quality as True.\n",
    "    if the first two parts are adjacent 'have 2 common nodes' the method will create a complex_surface with the candidate parts as parts of it.\n",
    "    The method could force the projection of the constructed nodes extremeties of one or both parts on an axis, for that force_projection_of_part_X_extremeties_on_axis\n",
    "        must be True, and an axis and its origin must be given\n",
    "\n",
    "    Parameter:\n",
    "    - planar1 : first candidate planar 'planar_surface'\n",
    "    - planar2 : second candidate planar 'planar_surface'\n",
    "    - tolerance_angle_parallel : tolerence degree to which the two planars are considered as parellel \n",
    "    - tolerance_angle_coplan : tolerence degree to which the two planars are considered as on the same plane\n",
    "    - physical_space : the physical space,\n",
    "    - knowledge_framework : the knowledge_framework, \n",
    "    - complex_surface : candidate complex_surface if it exists , \n",
    "    - complex_surface_name : proposed name of the complex_surface to construct, \n",
    "    - force_projection_of_part_1_extremeties_on_axis : boolean by default is False. If true it forces the projection of \n",
    "            the non-shared nodes of the constructed part1 on a given axis\n",
    "    - axis_1 : vector type array\n",
    "    - axis_1_origin : point type array\n",
    "    - force_projection_of_part_2_extremeties_on_axis : boolean by default is False. If true it forces the projection of \n",
    "            the non-shared nodes of the constructed part2 on a given axis\n",
    "    - axis_2 : vector type array\n",
    "    - axis_2_origin : point type arr\n",
    "\"\"\"  \n",
    "    \n",
    "    if complex_surface is not None:\n",
    "        complex_surface = complex_surface\n",
    "    else:\n",
    "        if complex_surface_name is not None :\n",
    "            complex_surface = knowledge_framework().Complex_Surface(name = complex_surface_name)\n",
    "        else:\n",
    "            complex_surface = knowledge_framework().Complex_Surface()\n",
    "    # change name of parts based on their number for part in complex_surf.has_Part....    \n",
    "    coord_labels = physical_space.coordinate_labels\n",
    "    # get candidate stratigraphic_parts paramters\n",
    "    n1 = np.array(physical_space.get_object_coordinates( object= planar1, kind= \"normal\")) \n",
    "    n2 = np.array(physical_space.get_object_coordinates( object= planar2, kind= \"normal\")) \n",
    "    c1 = np.array(physical_space.get_object_coordinates( object= planar1, kind= \"center\")) \n",
    "    c2 = np.array(physical_space.get_object_coordinates( object= planar2, kind= \"center\"))\n",
    "    # two cases could happen either they are parallel or not \n",
    "    parallelism = check_surface_parallelism(n1, n2,  tolerance = tolerance_angle_parallel)\n",
    "    # if the surfaces are parllel, they must be coplanar, have the same polarity and not totally overlapping to be able to build a complex surface\n",
    "    if parallelism is True: # this first block could be replaced by a try except block\n",
    "        \n",
    "        strati_part1_nodes = physical_space.get_object_coordinates( object= planar1, kind= \"nodes\")\n",
    "        strati_part2_nodes = physical_space.get_object_coordinates( object= planar2, kind= \"nodes\")\n",
    "        coplanar = check_if_two_surfaces_coplanar(point_on_surface1 = c1,  point_on_surface2 = c2,\n",
    "                                                    normal = n1, tolerance = tolerance_angle_coplan)\n",
    "        if coplanar is True:\n",
    "\n",
    "            inclusion1_in_2 = check_two_coplanar_surface_inclusion(candidate_larger_surface_nodes = strati_part2_nodes, \n",
    "                                                                    candidate_smaller_surface_nodes = strati_part1_nodes,\n",
    "                                                                    candidate_larger_surface_normal = n2)\n",
    "            inclusion2_in_1 = check_two_coplanar_surface_inclusion(candidate_larger_surface_nodes = strati_part1_nodes, \n",
    "                                                                    candidate_smaller_surface_nodes = strati_part2_nodes,\n",
    "                                                                    candidate_larger_surface_normal = n1)\n",
    "\n",
    "            if inclusion1_in_2 is True:\n",
    "                # return None\n",
    "                raise MalissiaNotImplementedYet ('{} is inluded totally in {}'.format(planar1.name, planar2.name))\n",
    "            elif inclusion2_in_1 is True:\n",
    "                # return None\n",
    "                raise MalissiaNotImplementedYet ('{} is inluded totally in {}'.format(planar2.name, planar1.name))\n",
    "            else:\n",
    "                common_nodes = common_two_nodes_two_planars(strati_part1_nodes, strati_part2_nodes, return_error = False)\n",
    "                if common_nodes is not None and len(common_nodes) == 2:\n",
    "                    complex_surface.has_Part.extend([planar1, planar2])\n",
    "                    neighbor_constructor_from_multiple_planars( complex_surface, knowledge_framework, physical_space)\n",
    "                    complex_surface.non_planar = False\n",
    "                    attribute_parts_nodes_to_complex_surface(complex_surface)\n",
    "                    return complex_surface\n",
    "                c1_to_c2_vec = c2-c1\n",
    "                separ_axis = np.cross(n1, c1_to_c2_vec)\n",
    "                side_size_1_tempo = physical_space.get_object_coordinates( object= planar1, kind= \"size\")\n",
    "                side_size_2_tempo = physical_space.get_object_coordinates( object= planar2, kind= \"size\")\n",
    "                ratio1 = side_size_1_tempo/(side_size_1_tempo + side_size_2_tempo)\n",
    "                ratio2 = side_size_2_tempo/(side_size_1_tempo + side_size_2_tempo)\n",
    "                dist_c1_c2 = np.linalg.norm(c2-c1)\n",
    "                point_inter = compute_endpoint(c1, c1_to_c2_vec, ratio1*dist_c1_c2)\n",
    "                side_size_common, start_point = compute_side_size_and_start_point(planar1,  \n",
    "                                                                    planar2, physical_space, \n",
    "                                                                        separ_axis, point_inter)\n",
    "                all_distances1 = [compute_distance_to_vector(n_i, point_inter, \n",
    "                                                                separ_axis) for n_i in strati_part1_nodes]\n",
    "                side_size1 = np.max(all_distances1)\n",
    "                all_distances2 = [compute_distance_to_vector(n_i, point_inter, \n",
    "                                                                separ_axis) for n_i in strati_part2_nodes]\n",
    "                side_size2 = np.max(all_distances2)\n",
    "                p1_v0 = start_point\n",
    "                p1_v1 = compute_endpoint(p1_v0, separ_axis, side_size_common)\n",
    "                p1_v2 = compute_endpoint(p1_v1, -c1_to_c2_vec, side_size1)\n",
    "                p1_v3 = compute_endpoint(p1_v2, -separ_axis, side_size_common)\n",
    "                nodes1_temp = [p1_v0, p1_v1, p1_v2, p1_v3]\n",
    "                p2_v0 = p1_v1\n",
    "                p2_v1 = start_point\n",
    "                p2_v2 = compute_endpoint(p2_v1, c1_to_c2_vec, side_size2)\n",
    "                p2_v3 = compute_endpoint(p2_v2, separ_axis, side_size_common)\n",
    "                nodes2_temp = [p2_v0, p2_v1, p2_v2, p2_v3]\n",
    "                new_complex_surface = complex_surface_two_planars_constructor(knowledge_framework, \n",
    "                                                                    physical_space, complex_surface, \n",
    "                                                            nodes1_temp, nodes2_temp, \n",
    "                                                            side_size= side_size2, force_non_planar_sign = False)\n",
    "                neighbor_constructor_from_multiple_planars(new_complex_surface, knowledge_framework, physical_space)\n",
    "                attribute_parts_nodes_to_complex_surface(new_complex_surface)\n",
    "                return new_complex_surface\n",
    "\n",
    "        \n",
    "        else:\n",
    "            projected_c1_on_plane2 = project_point_onto_plane(c1, strati_part2_nodes )\n",
    "            c1_to_c1_proj_vec = projected_c1_on_plane2-c1\n",
    "            dist_c1_proj = np.linalg.norm(c1_to_c1_proj_vec)\n",
    "            c1_to_c1_proj_vec /= dist_c1_proj\n",
    "            inverse_c1_to_c1_proj_vec = -c1_to_c1_proj_vec\n",
    "            \n",
    "            new_strati_part1_nodes = np.array([np.array(compute_endpoint(node_i, c1_to_c1_proj_vec, dist_c1_proj/2)) for node_i in strati_part1_nodes ])\n",
    "            new_strati_part2_nodes = np.array([np.array(compute_endpoint(node_i, inverse_c1_to_c1_proj_vec, dist_c1_proj/2)) for node_i in strati_part2_nodes ])\n",
    "            new_c1 = compute_center_nodes(new_strati_part1_nodes)\n",
    "            new_c2 = compute_center_nodes(new_strati_part2_nodes)\n",
    "            \n",
    "            c1_to_c2_vec = new_c2-new_c1\n",
    "            separ_axis = np.cross(n1, c1_to_c2_vec)\n",
    "            side_size_1_tempo = physical_space.get_object_coordinates( object= planar1, kind= \"size\")\n",
    "            side_size_2_tempo = physical_space.get_object_coordinates( object= planar2, kind= \"size\")\n",
    "            ratio1 = side_size_1_tempo/(side_size_1_tempo + side_size_2_tempo)\n",
    "            ratio2 = side_size_2_tempo/(side_size_1_tempo + side_size_2_tempo)\n",
    "            dist_c1_c2 = np.linalg.norm(new_c2-new_c1)\n",
    "            point_inter = compute_endpoint(new_c1, c1_to_c2_vec, ratio1*dist_c1_c2)\n",
    "            all_nodes =  [v for v in new_strati_part1_nodes ] + [v for v in new_strati_part2_nodes ]\n",
    "            \n",
    "            side_size_common, start_point = compute_side_size_and_start_point(planar1,  \n",
    "                                                                planar2, physical_space, \n",
    "                                                                    separ_axis, point_inter, all_surfaces_nodes= all_nodes)\n",
    "            all_distances1 = [compute_distance_to_vector(n_i, point_inter, \n",
    "                                                            separ_axis) for n_i in new_strati_part1_nodes]\n",
    "            side_size1 = np.max(all_distances1)\n",
    "            all_distances2 = [compute_distance_to_vector(n_i, point_inter, \n",
    "                                                            separ_axis) for n_i in new_strati_part2_nodes]\n",
    "            side_size2 = np.max(all_distances2)\n",
    "            p1_v0 = start_point\n",
    "            p1_v1 = compute_endpoint(p1_v0, separ_axis, side_size_common)\n",
    "            p1_v2 = compute_endpoint(p1_v1, -c1_to_c2_vec, side_size1)\n",
    "            p1_v3 = compute_endpoint(p1_v2, -separ_axis, side_size_common)\n",
    "            nodes1_temp = [p1_v0, p1_v1, p1_v2, p1_v3]\n",
    "            p2_v0 = p1_v1\n",
    "            p2_v1 = start_point\n",
    "            p2_v2 = compute_endpoint(p2_v1, c1_to_c2_vec, side_size2)\n",
    "            p2_v3 = compute_endpoint(p2_v2, separ_axis, side_size_common)\n",
    "            nodes2_temp = [p2_v0, p2_v1, p2_v2, p2_v3]\n",
    "            if force_projection_of_part_1_extremeties_on_axis == True:\n",
    "                if axis_1 is None or axis_2_origin is None :\n",
    "                    raise MalissiaBaseError('to project new_part1 extermeties on an axis, axis_1 and its origin must be given')\n",
    "                else:\n",
    "                    p1_v2 = np.array(compute_point_projection_onto_line(nodes1_temp[2],axis_1_origin, axis_1))\n",
    "                    p1_v3 = np.array(compute_point_projection_onto_line(nodes1_temp[3],axis_1_origin, axis_1))\n",
    "                    nodes1_temp =  [nodes1_temp[0], nodes1_temp[1], p1_v2, p1_v3]\n",
    "                    \n",
    "                    \n",
    "            if force_projection_of_part_2_extremeties_on_axis == True:\n",
    "                if axis_2 is None or axis_2_origin is None :\n",
    "                    raise MalissiaBaseError('to project new_part2 extermeties on an axis, axis_2 and its origin must be given')\n",
    "                else:\n",
    "                    p2_v2 = np.array(compute_point_projection_onto_line(nodes2_temp[2],axis_2_origin, axis_2))\n",
    "                    p2_v3 = np.array(compute_point_projection_onto_line(nodes2_temp[3],axis_2_origin, axis_2))\n",
    "                    nodes2_temp =  [nodes2_temp[0], nodes2_temp[1], p2_v2, p2_v3]\n",
    "\n",
    "\n",
    "            new_complex_surface = complex_surface_two_planars_constructor(knowledge_framework, physical_space, complex_surface, \n",
    "                                                        nodes1_temp, nodes2_temp, side_size= side_size_common, \n",
    "                                                        force_non_planar_sign = False,\n",
    "                                                        forced_p2_v3 = forced_p2_v3, \n",
    "                                          forced_p2_v2 = forced_p2_v2, \n",
    "                                          forced_p1_v3 = forced_p1_v3, \n",
    "                                          forced_p1_v2 = forced_p1_v2)\n",
    "            neighbor_constructor_from_multiple_planars( new_complex_surface, knowledge_framework, physical_space)\n",
    "            attribute_parts_nodes_to_complex_surface(new_complex_surface)\n",
    "            return new_complex_surface         \n",
    "            \n",
    "        \n",
    "\n",
    "    # in case the candidatesurfaces are not parallel the construction of \n",
    "        # a complex surface could be approach as fold construction\n",
    "    else:\n",
    "        # check chirality imprtant as the same quality as pola or para \n",
    "        # using methods of fold constuction compute an intersection point and a side \n",
    "            ## \"fold axis and limbs are only nomination of parammters that are used to compute but not used as folding paramters\"\n",
    "        part1_nodes = physical_space.get_object_coordinates( object= planar1, kind= \"nodes\")\n",
    "        part2_nodes = physical_space.get_object_coordinates( object= planar2, kind= \"nodes\")    \n",
    "        common_nodes = common_two_nodes_two_planars(part1_nodes, part2_nodes, return_error = False)\n",
    "        if common_nodes is not None and len(common_nodes) == 2:\n",
    "            complex_surface.has_Part.extend([planar1, planar2])\n",
    "            neighbor_constructor_from_multiple_planars( complex_surface, knowledge_framework, physical_space)\n",
    "            complex_surface.non_planar = True\n",
    "            attribute_parts_nodes_to_complex_surface(complex_surface)\n",
    "            return complex_surface    \n",
    "           \n",
    "        axis = compute_fold_axis(n1 = n1, c1 =  c1, n2 = n2, c2 = c2)\n",
    "        intersection_point = compute_intersection_point(plane1_center=c1, \n",
    "                                                    plane1_normal= n1,plane2_center=c2, \n",
    "                                                    plane2_normal= n2, fold_axis= axis)\n",
    "        ## get side_size and start point\n",
    "        side_size, start_point = compute_side_size_and_start_point(limb_part1 = planar1,  limb_part2 = planar2,\n",
    "                                   physical_space = physical_space,  fold_axis = axis, \n",
    "                                   intersection_point = intersection_point)\n",
    "        nodes1_temp = compute_shape_limb1(start_point, axis, side_size,  n1)\n",
    "        vertex0, vertex1 = nodes1_temp[1],  nodes1_temp[0]\n",
    "        nodes2_temp = compute_shape_limb2( vertex0, vertex1 , axis, side_size,  n2)\n",
    "\n",
    "        if force_projection_of_part_1_extremeties_on_axis == True:\n",
    "            if axis_1 is None or axis_2_origin is None :\n",
    "                raise MalissiaBaseError('to project new_part1 extermeties on an axis, axis_1 and its origin must be given')\n",
    "            else:\n",
    "                p1_v2 = np.array(compute_point_projection_onto_line(nodes1_temp[2],axis_1_origin, axis_1))\n",
    "                p1_v3 = np.array(compute_point_projection_onto_line(nodes1_temp[3],axis_1_origin, axis_1))\n",
    "                nodes1_temp =  [nodes1_temp[0], nodes1_temp[1], p1_v2, p1_v3]\n",
    "                \n",
    "                for i in range(0,4):\n",
    "                    name_prop = 'has_Node{}'.format(i)\n",
    "                    v = np.array(physical_space.get_object_coordinates(getattr(planar1, name_prop)[0], 'nodes')[0])\n",
    "                    diff = np.linalg.norm(p1_v2 - v)\n",
    "                    if diff <= tolerance:\n",
    "                        forced_p1_v2 = getattr(planar1, name_prop)[0]\n",
    "                        break\n",
    "\n",
    "                for i in range(0,4):\n",
    "                    name_prop = 'has_Node{}'.format(i)\n",
    "                    v = np.array(physical_space.get_object_coordinates(getattr(planar1, name_prop)[0], 'nodes')[0])\n",
    "                    diff = np.linalg.norm(p1_v3 - v)\n",
    "                    if diff <= tolerance:\n",
    "                        forced_p1_v3 = getattr(planar1, name_prop)[0]\n",
    "                        break\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "        if force_projection_of_part_2_extremeties_on_axis == True:\n",
    "            if axis_2 is None or axis_2_origin is None :\n",
    "                raise MalissiaBaseError('to project new_part2 extermeties on an axis, axis_2 and its origin must be given')\n",
    "            else:\n",
    "                p2_v2 = np.array(compute_point_projection_onto_line(nodes2_temp[2],axis_2_origin, axis_2))\n",
    "                p2_v3 = np.array(compute_point_projection_onto_line(nodes2_temp[3],axis_2_origin, axis_2))\n",
    "                nodes2_temp =  [nodes2_temp[0], nodes2_temp[1], p2_v2, p2_v3]\n",
    "\n",
    "                \n",
    "                for i in range(0,4):\n",
    "                    name_prop = 'has_Node{}'.format(i)\n",
    "                    v = np.array(physical_space.get_object_coordinates(getattr(planar2, name_prop)[0], 'nodes')[0])\n",
    "                    diff = np.linalg.norm(p2_v2 - v)\n",
    "                    if diff <= tolerance:\n",
    "                        forced_p2_v2 = getattr(planar2, name_prop)[0]\n",
    "                        break\n",
    "\n",
    "                for i in range(0,4):\n",
    "                    name_prop = 'has_Node{}'.format(i)\n",
    "                    v = np.array(physical_space.get_object_coordinates(getattr(planar2, name_prop)[0], 'nodes')[0])\n",
    "                    diff = np.linalg.norm(p2_v3 - v)\n",
    "                    if diff <= tolerance:\n",
    "                        forced_p2_v3 = getattr(planar2, name_prop)[0]\n",
    "                        break\n",
    "\n",
    "\n",
    "        new_complex_surface =  complex_surface_two_planars_constructor(knowledge_framework, physical_space, complex_surface, \n",
    "                                                        nodes1_temp, nodes2_temp,  \n",
    "                                                        side_size= side_size, force_non_planar_sign= True,\n",
    "                                                        forced_p2_v3 = forced_p2_v3, \n",
    "                                          forced_p2_v2 = forced_p2_v2, \n",
    "                                          forced_p1_v3 = forced_p1_v3, \n",
    "                                          forced_p1_v2 = forced_p1_v2,)\n",
    "        neighbor_constructor_from_multiple_planars( new_complex_surface, knowledge_framework, physical_space)\n",
    "        attribute_parts_nodes_to_complex_surface(new_complex_surface)\n",
    "        return new_complex_surface\n",
    "\n",
    "\n",
    "def compute_complex_surface_from_complex_surface_and_planar(candidate_complex_surface, planar, \n",
    "                                                              knowledge_framework, physical_space,\n",
    "                                                              new_complex_surface_name = None, \n",
    "                                                              chosen_part_to_join = None, \n",
    "                                                              tolerance_angle_parallel = 3, \n",
    "                                                              tolerance_angle_coplan = 3 ):\n",
    "    \"\"\"\n",
    "    Method to compute a complex_surface from a candidate_complex_surface and a planar. It returns a new complex_surface. \n",
    "    At this stage, chosen_part_to_join must be given (one of the candidate_complex_surface extremete faces).\n",
    "\n",
    "\n",
    "    Parameter:\n",
    "    - candidate_complex_surface : the candidate_complex_surface \n",
    "    - planar : candidate planar \n",
    "    - knowledge_framework : the knowledge_framework \n",
    "    - physical_space : the physical_space\n",
    "    - new_complex_surface_name : type str, optional variable holding a desired name for the new_complex_surface  \n",
    "    - chosen_part_to_join : a chosen part to join with the planar \n",
    "    - tolerance_angle_parallel : tolerence degree to which the two planars are considered as parellel \n",
    "    - tolerance_angle_coplan : tolerence degree to which the two planars are considered as on the same plane \n",
    "\"\"\"  \n",
    "    \n",
    "\n",
    "    if new_complex_surface_name is not None :\n",
    "        new_complex_surface = knowledge_framework().Complex_Surface( name = new_complex_surface_name,)\n",
    "    else:\n",
    "        nb_cplx = len(knowledge_framework().Complex_Surface.instances())\n",
    "        new_complex_surface_name = 'Cmpx_Su_{}'.format(nb_cplx +1)\n",
    "        new_complex_surface = knowledge_framework().Complex_Surface( name = new_complex_surface_name)\n",
    "    \n",
    "    if chosen_part_to_join is not None:\n",
    "        # check if the chosen_part_to_join has only one neighbor in the candidate complex_surface\n",
    "        neighbors_of_part_tojoin = chosen_part_to_join.has_Neighbor\n",
    "        neighbor_of_part_tojoin_in_cplx_surf = list(set(candidate_complex_surface.has_Part).intersection(neighbors_of_part_tojoin))\n",
    "        if len(neighbor_of_part_tojoin_in_cplx_surf) != 1:\n",
    "            raise MalissiaBaseError('the  {} used as chosen_part_to_join is an extreme face and must have exactly one neighbor \\\n",
    "                                    in the candidate complex_surface {} '.format(chosen_part_to_join.name, candidate_complex_surface.name ))\n",
    "        \n",
    "        shared_intersection = list(set(chosen_part_to_join.has_Shared_Side).intersection(neighbor_of_part_tojoin_in_cplx_surf[0].has_Shared_Side))\n",
    "        if len(shared_intersection) != 1:\n",
    "            raise MalissiaBaseError('the  {} used as chosen_part_to_join must have exactly one shared side with its neighbor in \\\n",
    "                                    in the candidate complex_surface {} '.format(chosen_part_to_join.name, candidate_complex_surface.name ))\n",
    "        shared_side = shared_intersection[0]\n",
    "        point_0 = physical_space.get_object_coordinates( object= shared_side.has_End_Points[0], kind= \"node\")[0] \n",
    "        point_1 = physical_space.get_object_coordinates( object= shared_side.has_End_Points[1], kind= \"node\")[0] \n",
    "        shared_side_vec = np.array(point_0) - np.array(point_1)\n",
    "\n",
    "        \n",
    "\n",
    "        new_complex_surface = compute_complex_surface_two_planars( planar1= planar, \n",
    "                                                   planar2= chosen_part_to_join,\n",
    "                                                   tolerance_angle_parallel = tolerance_angle_parallel, \n",
    "                                                    tolerance_angle_coplan = tolerance_angle_coplan, \n",
    "                                                    physical_space = physical_space, \n",
    "                                                    knowledge_framework = knowledge_framework, \n",
    "                                                    complex_surface = new_complex_surface,  \n",
    "                                                    force_projection_of_part_2_extremeties_on_axis= True, \n",
    "                                                    axis_2= shared_side_vec, axis_2_origin = point_0)\n",
    "        \n",
    "        for part in candidate_complex_surface.has_Part:\n",
    "            if part != chosen_part_to_join and part not in  new_complex_surface.has_Part :\n",
    "                new_complex_surface.has_Part.append(part)\n",
    "        if new_complex_surface.non_planar != True:\n",
    "            new_complex_surface.non_planar = True\n",
    "        neighbor_constructor_from_multiple_planars( new_complex_surface, knowledge_framework, physical_space)\n",
    "        attribute_parts_nodes_to_complex_surface(new_complex_surface)\n",
    "        return new_complex_surface\n",
    "\n",
    "    else:\n",
    "        extreme_faces = compute_complex_surface_extreme_surfaces(knowledge_framework, \n",
    "                                                                 candidate_complex_surface)\n",
    "        if len(extreme_faces)!=2:\n",
    "            raise MalissiaBaseError('the candidate complex_surface {} has {} extreme faces'.format(candidate_complex_surface.name,\n",
    "                                                                                                    len(extreme_faces))) \n",
    "        center_planar = physical_space.get_object_coordinates(planar, \"center\")\n",
    "        face1_center = physical_space.get_object_coordinates(extreme_faces[0], \"center\")\n",
    "        face2_center = physical_space.get_object_coordinates(extreme_faces[1], \"center\")\n",
    "\n",
    "        dist_face1_c = np.linalg.norm(np.array(center_planar)-np.array(face1_center))\n",
    "        dist_face2_c = np.linalg.norm(np.array(center_planar)-np.array(face2_center))\n",
    "        chosen_part_to_join = extreme_faces[0] if dist_face1_c <= dist_face2_c else extreme_faces[1]\n",
    "        return compute_complex_surface_from_complex_surface_and_planar(candidate_complex_surface, planar, \n",
    "                                                              knowledge_framework = knowledge_framework, \n",
    "                                                              physical_space = physical_space ,\n",
    "                                                              new_complex_surface_name = new_complex_surface_name, \n",
    "                                                              chosen_part_to_join = chosen_part_to_join, \n",
    "                                                              tolerance_angle_parallel = tolerance_angle_parallel, \n",
    "                                                              tolerance_angle_coplan = tolerance_angle_coplan )\n",
    "\n",
    "  \n",
    "def compute_complex_surface_from_two_complex_surfaces(complex_surface1, complex_surface2,  \n",
    "                                                              knowledge_framework, physical_space,\n",
    "                                                              chosen_part_to_join_1 = None, \n",
    "                                                              chosen_part_to_join_2 = None,\n",
    "                                                              new_complex_surface_name = None, \n",
    "                                                              tolerance_angle_parallel = 3, \n",
    "                                                              tolerance_angle_coplan = 3 ):\n",
    "    \"\"\"\n",
    "    Method to compute a complex_surface from two candidate_complex_surfaces. It returns a new complex_surface. \n",
    "    At this stage, chosen_part_to_join_1 and chosen_part_to_join_2 must be given (one of the candidate_complex_surface extremete faces).\n",
    "\n",
    "    Parameter:\n",
    "    - Complex_surface1 : the candidate_complex_surface1\n",
    "    - Complex_surface2 : the candidate_complex_surface2  \n",
    "    - knowledge_framework : the knowledge_framework \n",
    "    - physical_space : the physical_space\n",
    "    - new_complex_surface_name : type str, optional variable holding a desired name for the new_complex_surface  \n",
    "    - chosen_part_to_join_1 : a chosen part to join from the candidate_complex_surface1\n",
    "    - chosen_part_to_join_2 : a chosen part to join from the candidate_complex_surface2\n",
    "    - tolerance_angle_parallel : tolerence degree to which the two planars are considered as parellel \n",
    "    - tolerance_angle_coplan : tolerence degree to which the two planars are considered as on the same plane \n",
    "    \"\"\"     \n",
    "    \n",
    "    if new_complex_surface_name is not None :\n",
    "        new_complex_surface = knowledge_framework().Complex_Surface( name = new_complex_surface_name)\n",
    "    else:\n",
    "        nb_cplx = len(knowledge_framework().Complex_Surface.instances())\n",
    "        new_complex_surface_name = 'Cmpx_Su_{}'.format(nb_cplx +1)\n",
    "        new_complex_surface = knowledge_framework().Complex_Surface( name = new_complex_surface_name)\n",
    "    \n",
    "    if chosen_part_to_join_1 is not None and chosen_part_to_join_2 is not None : \n",
    "        print(chosen_part_to_join_1, chosen_part_to_join_2)\n",
    "        # check if the chosen_part_to_join has only one neighbor in the candidate complex_surface1\n",
    "        neighbors_of_part_tojoin1 = chosen_part_to_join_1.has_Neighbor\n",
    "        neighbor_of_part_tojoin_in_cplx_surf1 = list(set(complex_surface1.has_Part).intersection(neighbors_of_part_tojoin1))\n",
    "        if len(neighbor_of_part_tojoin_in_cplx_surf1) != 1:\n",
    "            raise MalissiaBaseError('the  {} used as chosen_part_to_join is an extreme face and must have exactly one neighbor \\\n",
    "                                    in the candidate complex_surface {} '.format(chosen_part_to_join_1.name, complex_surface1.name ))\n",
    "        \n",
    "        shared_intersection1 = list(set(chosen_part_to_join_1.has_Shared_Side).intersection(neighbor_of_part_tojoin_in_cplx_surf1[0].has_Shared_Side))\n",
    "        if len(shared_intersection1) != 1:\n",
    "            raise MalissiaBaseError('the  {} used as chosen_part_to_join must have exactly one shared side with its neighbor in \\\n",
    "                                    in the candidate complex_surface {} '.format(chosen_part_to_join_1.name, complex_surface1.name ))\n",
    "        shared_side1 = shared_intersection1[0]\n",
    "        point1_0 = physical_space.get_object_coordinates( object= shared_side1.has_End_Points[0], kind= \"node\")[0] \n",
    "        point1_1 = physical_space.get_object_coordinates( object= shared_side1.has_End_Points[1], kind= \"node\")[0] \n",
    "        shared_side_vec1 = np.array(point1_0) - np.array(point1_1)\n",
    "\n",
    "        # check if the chosen_part_to_join has only one neighbor in the candidate complex_surface2\n",
    "        neighbors_of_part_tojoin2 = chosen_part_to_join_2.has_Neighbor\n",
    "        neighbor_of_part_tojoin_in_cplx_surf2 = list(set(complex_surface2.has_Part).intersection(neighbors_of_part_tojoin2))\n",
    "        if len(neighbor_of_part_tojoin_in_cplx_surf2) != 1:\n",
    "            raise MalissiaBaseError('the  {} used as chosen_part_to_join is an extreme face and must have exactly one neighbor \\\n",
    "                                    in the candidate complex_surface {} '.format(chosen_part_to_join_2.name, complex_surface2.name ))\n",
    "        \n",
    "        shared_intersection2 = list(set(chosen_part_to_join_2.has_Shared_Side).intersection(neighbor_of_part_tojoin_in_cplx_surf2[0].has_Shared_Side))\n",
    "        if len(shared_intersection2) != 1:\n",
    "            raise MalissiaBaseError('the  {} used as chosen_part_to_join must have exactly one shared side with its neighbor in \\\n",
    "                                    in the candidate complex_surface {} '.format(chosen_part_to_join_2.name, complex_surface2.name ))\n",
    "        shared_side2 = shared_intersection2[0]\n",
    "        point2_0 = physical_space.get_object_coordinates( object= shared_side2.has_End_Points[0], kind= \"node\")[0] \n",
    "        point2_1 = physical_space.get_object_coordinates( object= shared_side2.has_End_Points[1], kind= \"node\")[0] \n",
    "        shared_side_vec2 = np.array(point2_0) - np.array(point2_1)\n",
    "\n",
    "\n",
    "        new_complex_surface= compute_complex_surface_two_planars(chosen_part_to_join_1, chosen_part_to_join_2, \n",
    "                                    tolerance_angle_parallel = tolerance_angle_parallel, \n",
    "                                    tolerance_angle_coplan = tolerance_angle_coplan, \n",
    "                                    physical_space = physical_space,\n",
    "                                    knowledge_framework = knowledge_framework, \n",
    "                                    complex_surface = new_complex_surface,  \n",
    "                                    force_projection_of_part_1_extremeties_on_axis= True, \n",
    "                                    axis_1= shared_side_vec1, axis_1_origin= point1_0, \n",
    "                                    force_projection_of_part_2_extremeties_on_axis= True, \n",
    "                                    axis_2= shared_side_vec2 , axis_2_origin= point2_0 )\n",
    "        \n",
    "        for part in complex_surface1.has_Part:\n",
    "            if part !=  chosen_part_to_join_1 and part not in  new_complex_surface.has_Part :\n",
    "                new_complex_surface.has_Part.append(part)\n",
    "        for part in complex_surface2.has_Part:\n",
    "            if part != chosen_part_to_join_2 and part not in  new_complex_surface.has_Part :\n",
    "                new_complex_surface.has_Part.append(part)\n",
    "        if new_complex_surface.non_planar != True:\n",
    "            new_complex_surface.non_planar = True\n",
    "        neighbor_constructor_from_multiple_planars( new_complex_surface, knowledge_framework, physical_space)\n",
    "        attribute_parts_nodes_to_complex_surface(new_complex_surface)\n",
    "        return new_complex_surface\n",
    "    \n",
    "    elif  chosen_part_to_join_1 is  None and chosen_part_to_join_2 is  None :\n",
    "        extrem_faces_1 = compute_complex_surface_extreme_surfaces(knowledge_framework, complex_surface1)\n",
    "        if len(extrem_faces_1)!=2:\n",
    "            raise MalissiaBaseError('the candidate complex_surface {} has {} extreme faces'.format(complex_surface1.name,\n",
    "                                                                                                    len(extrem_faces_1))) \n",
    "        extrem_faces_2 = compute_complex_surface_extreme_surfaces(knowledge_framework, complex_surface2)\n",
    "        if len(extrem_faces_2)!=2:\n",
    "            raise MalissiaBaseError('the candidate complex_surface {} has {} extreme faces'.format(complex_surface2.name,\n",
    "                                                                                                    len(extrem_faces_2))) \n",
    "        min_distance =  float('inf')\n",
    "        for face_1 in extrem_faces_1:\n",
    "            face_1_center = physical_space.get_object_coordinates(face_1, \"center\")\n",
    "            for face_2 in extrem_faces_2:\n",
    "                face_2_center = physical_space.get_object_coordinates(face_2, \"center\")\n",
    "                distance = np.linalg.norm(np.array(face_1_center) - np.array(face_2_center))\n",
    "                if distance < min_distance:\n",
    "                    min_distance = distance\n",
    "                    closest_faces = [face_1, face_2]\n",
    "                    \n",
    "        return compute_complex_surface_from_two_complex_surfaces(complex_surface1, complex_surface2, \n",
    "                                                      chosen_part_to_join_1 = closest_faces[0], \n",
    "                                                      chosen_part_to_join_2 = closest_faces[1], \n",
    "                                                              knowledge_framework = knowledge_framework,\n",
    "                                                              physical_space = physical_space ,\n",
    "                                                              new_complex_surface_name = new_complex_surface_name, \n",
    "                                                              tolerance_angle_parallel = tolerance_angle_parallel, \n",
    "                                                              tolerance_angle_coplan = tolerance_angle_coplan )\n",
    "    else:\n",
    "        raise MalissiaNotImplementedYet('chosen_part_to_join_1 and chosen_part_to_join_2 must be given both or missing both but not one given and the other missing')\n",
    "    \n",
    "\n",
    "def are_points_coplanar(points):\n",
    "    # Check if the list has at least three points\n",
    "    if len(points) < 3:\n",
    "        return False\n",
    "\n",
    "    # Extract the first three points to define the plane\n",
    "    p1, p2, p3 = points[:3]\n",
    "\n",
    "    # Calculate the normal vector of the plane formed by the first three points\n",
    "    normal_vector = np.cross(p2 - p1, p3 - p1)\n",
    "\n",
    "    # Check if the remaining points lie on the same plane\n",
    "    for point in points[3:]:\n",
    "        # Calculate the vector from p1 to the current point\n",
    "        vector_to_point = point - p1\n",
    "\n",
    "        # Check if the vector is orthogonal to the normal vector\n",
    "        if not np.allclose(np.dot(vector_to_point, normal_vector), 0):\n",
    "            return False\n",
    "\n",
    "    return True        \n",
    "\n",
    "def part_explained_by_part( explainable_features):\n",
    "    \"\"\"Method to ensure that a parat is not already explained by another part or itslef in features to explain\"\"\"\n",
    "\n",
    "    feature0 = explainable_features[0]\n",
    "    feature1 = explainable_features[1]\n",
    "    if feature0 is feature1:\n",
    "        print(' Warning: objects to explain are {}, thus the same object. An object intrinsically explains itslef'.format(explainable_features))\n",
    "        return True, feature0\n",
    "\n",
    "    if feature0 in feature1.explain or feature0 in feature1.has_Part:\n",
    "        print(' {} is already explained and part of {}'.format(feature0, feature1))\n",
    "        if feature0 not in feature1.explain:\n",
    "            feature1.explain.append(feature0)\n",
    "        if feature0 not in feature1.has_Part:\n",
    "            feature1.has_Part.append(feature0)\n",
    "        return True, feature1\n",
    "    if feature1 in feature0.explain or feature1 in feature0.has_Part:\n",
    "        print(' {} is already explained and part of {}'.format(feature1, feature0))\n",
    "        if feature1 not in feature0.explain:\n",
    "            feature0.explain.append(feature1)\n",
    "        if feature1 not in feature0.has_Part:\n",
    "            feature0.has_Part.append(feature1)\n",
    "        return True, feature0\n",
    "    return False, None\n",
    "\n",
    "\n",
    "def rep_in_rep( physical_space, rep_feature_1, rep_feature_2, feature1, feature2, use_case  ):\n",
    "    \"\"\"Method to ensure that a parat is not already explained by another part through their representation or itslef in features to explain\"\"\"\n",
    "\n",
    "    if rep_feature_1 is rep_feature_2:\n",
    "        print(' Warning: objects to explain are {}{}, with these same representations {}{}, which means they are the same object. An object intrinsically explains itslef'.format(feature1,\n",
    "                                                                                                    feature2, rep_feature_1, rep_feature_2))\n",
    "        return True, feature1 \n",
    "    \n",
    "    if use_case == \"complx_rep_in_complx_rep\":\n",
    "        answ, obj =  complx_rep_in_complx_rep( physical_space, \n",
    "                                        rep_feature_1, rep_feature_2, \n",
    "                                        feature1, feature2)\n",
    "        if answ: return answ, obj\n",
    "        # inverse the rep and objects\n",
    "        if not answ: return complx_rep_in_complx_rep(physical_space, \n",
    "                                        rep_feature_1 = rep_feature_2, rep_feature_2 =rep_feature_1, \n",
    "                                        feature1 = feature2, feature2 = feature1)\n",
    "    if use_case == \"part_in_complx_rep\":\n",
    "        return part_in_complx_rep(physical_space, rep_feature_1, rep_feature_2, feature1, feature2, )\n",
    "    \n",
    "    if use_case == \"part_in_part\":\n",
    "        answ, obj =  part_rep_in_part_rep( physical_space, \n",
    "                                        rep_feature_1, rep_feature_2, \n",
    "                                        feature1, feature2)\n",
    "        if answ: return answ, obj\n",
    "        # inverse the rep and objects\n",
    "        if not answ: return part_rep_in_part_rep(physical_space, \n",
    "                                        rep_feature_1 = rep_feature_2, rep_feature_2 =rep_feature_1, \n",
    "                                        feature1 = feature2, feature2 = feature1)\n",
    "    \n",
    "\n",
    "\n",
    "     \n",
    "    \n",
    "\n",
    "def complx_rep_in_complx_rep(physical_space, rep_feature_1, rep_feature_2, feature1, feature2):    \n",
    "    # for now the method only search for a total inclusion of one surface in another\n",
    "    ## todo: add methods to check if /\\ covers a part of \\/\\/ or \\/\\/ sahre parts with \\/\\/\\ \n",
    "\n",
    "    if all([part_i in rep_feature_2.has_Part for part_i in  rep_feature_1.has_Part]):\n",
    "        print(' {} is already explained and part of {} through their representation'.format(feature2,\n",
    "                                                                                    feature1))\n",
    "        return True, feature2\n",
    "    \n",
    "    rep1_tot_in_rep2 = [] \n",
    "    for part in rep_feature_1.has_Part:\n",
    "        part_nodes = physical_space.get_object_coordinates(part, \"nodes\")\n",
    "        part1_in_part2 = False\n",
    "        for part_2 in rep_feature_2.has_Part:\n",
    "            part_2_nodes = physical_space.get_object_coordinates(part_2, \"nodes\")\n",
    "            part_2_normal = physical_space.get_object_coordinates(part_2, \"normal\")\n",
    "            all_points = np.concatenate((part_nodes, part_2_nodes))\n",
    "            if are_points_coplanar(all_points)   and   check_two_coplanar_surface_inclusion(part_2_nodes, \n",
    "                                                part_nodes, part_2_normal ):\n",
    "                part1_in_part2 = True\n",
    "                rep1_tot_in_rep2.append(True)\n",
    "                break\n",
    "        if part1_in_part2 is False:\n",
    "            rep1_tot_in_rep2.appendd(False)\n",
    "            break\n",
    "    if all(rep1_tot_in_rep2):\n",
    "        if feature1 not in feature2.explain :\n",
    "            feature2.explain.append(feature1)\n",
    "        if feature1 not in feature2.has_Part :\n",
    "            feature2.has_Part.append(feature1)\n",
    "        print('warning {} is already explained and part of {} through their representation'.format(feature2,\n",
    "                                                                                    feature1))    \n",
    "        return True, feature2\n",
    "    else:\n",
    "        return False, None\n",
    "    \n",
    "\n",
    "def part_in_complx_rep(physical_space, part_rep, complex_rep, strati_part, strati_complx):\n",
    "\n",
    "    if part_rep in complex_rep.has_Part:\n",
    "        if strati_part not in strati_complx.has_Part:\n",
    "            strati_complx.has_Part.append(strati_part)\n",
    "        if strati_part not in strati_complx.explain :\n",
    "            strati_complx.explain.append(strati_part)\n",
    "        print('Warning :  {} is already explained and part of {} through their representation'.format(strati_part,\n",
    "                                                                                    strati_complx))\n",
    "        return True, strati_complx\n",
    "    \n",
    "    part_nodes = physical_space.get_object_coordinates(part_rep, \"nodes\")\n",
    "    for part_2 in complex_rep.has_Part:\n",
    "        part_2_nodes = physical_space.get_object_coordinates(part_2, \"nodes\")\n",
    "        part_2_normal = physical_space.get_object_coordinates(part_2, \"normal\")\n",
    "        all_points = np.concatenate((part_nodes, part_2_nodes))\n",
    "        if are_points_coplanar(all_points)   and   check_two_coplanar_surface_inclusion(part_2_nodes, part_nodes, part_2_normal ):\n",
    "            if strati_part not in strati_complx.has_Part:\n",
    "                strati_complx.has_Part.append(strati_part)\n",
    "            if strati_part not in strati_complx.explain :\n",
    "                strati_complx.explain.append(strati_part)\n",
    "            print('Warning :  {} is already explained and part of {} through their representation'.format(strati_part,\n",
    "                                                                                    strati_complx))\n",
    "            return True, strati_complx\n",
    "    return False, None\n",
    "    \n",
    "\n",
    "def part_rep_in_part_rep(physical_space, rep_feature_1, rep_feature_2, feature1, feature2, ):\n",
    "    part_nodes = physical_space.get_object_coordinates(rep_feature_1, \"nodes\")\n",
    "    part_2_nodes = physical_space.get_object_coordinates(rep_feature_2, \"nodes\")\n",
    "    part_2_normal = physical_space.get_object_coordinates(rep_feature_2, \"normal\")\n",
    "    all_points = np.concatenate((part_nodes, part_2_nodes))\n",
    "    if are_points_coplanar(all_points)   and   check_two_coplanar_surface_inclusion(part_2_nodes, part_nodes, part_2_normal ):\n",
    "        if feature1 not in feature2.explain :\n",
    "            feature2.explain.append(feature1)\n",
    "        print('Warning :  {} is already explained and part of {} through their representation'.format(feature1,\n",
    "                                                                                    feature2))\n",
    "        return True, feature2\n",
    "    return False, None\n",
    "\n",
    "            \n",
    "            \n",
    "\n",
    "\n",
    "def construct_complex_stratigraphic_part(knowledge_framework,  explainable_features, physical_space,\n",
    "                                         name_object = None, name_rep = None):\n",
    "    \"\"\"\n",
    "    Method to construct a stratigraphic_part \n",
    "    \"\"\" \n",
    "    \n",
    "    if len(explainable_features[0].has_Representation) == 0 or len (explainable_features[1].has_Representation) ==0 :\n",
    "        print(\"Warning: explainable_features are missing representation. To be implemented.\")\n",
    "        return None\n",
    "    rep_feature_1 = explainable_features[0].has_Representation[0]\n",
    "    rep_feature_2 = explainable_features[1].has_Representation[0]\n",
    "    feature1 = explainable_features[0]\n",
    "    feature2 = explainable_features[1]\n",
    "    \n",
    "    redundant_explaiantion, explaining_object = part_explained_by_part( explainable_features)\n",
    "    if redundant_explaiantion: return explaining_object\n",
    "    \n",
    "\n",
    "    if knowledge_framework().Complex_Surface in rep_feature_1.is_a and  knowledge_framework().Complex_Surface in rep_feature_2.is_a:\n",
    "        redundant_explaiantion, explaining_object = rep_in_rep( physical_space, rep_feature_1, rep_feature_2, \n",
    "                                                                         feature1, feature2, use_case = \"complx_rep_in_complx_rep\" )\n",
    "        if redundant_explaiantion: return explaining_object \n",
    "        complex_surface = compute_complex_surface_from_two_complex_surfaces(rep_feature_1, \n",
    "                                                                            rep_feature_2,\n",
    "                                                                            knowledge_framework = knowledge_framework, \n",
    "                                                                            physical_space= physical_space \n",
    "                                                                            , new_complex_surface_name= name_rep)\n",
    "        \n",
    "    elif knowledge_framework().Planar_Surface in rep_feature_1.is_a and  knowledge_framework().Complex_Surface in rep_feature_2.is_a:\n",
    "        redundant_explaiantion, explaining_object = rep_in_rep( physical_space, rep_feature_1, rep_feature_2, \n",
    "                                                                         feature1, feature2, use_case = \"part_in_complx_rep\" )\n",
    "        if redundant_explaiantion: return explaining_object \n",
    "        complex_surface = compute_complex_surface_from_complex_surface_and_planar( rep_feature_2, \n",
    "                                                                                  rep_feature_1, \n",
    "                                                                                  knowledge_framework= knowledge_framework, \n",
    "                                                                                  physical_space=physical_space, \n",
    "                                                                                    new_complex_surface_name = name_rep)\n",
    "         \n",
    "    elif knowledge_framework().Complex_Surface in rep_feature_1.is_a and  knowledge_framework().Planar_Surface in rep_feature_2.is_a:\n",
    "        redundant_explaiantion, explaining_object = rep_in_rep( physical_space, rep_feature_2, rep_feature_1, \n",
    "                                                                         feature2, feature1, use_case = \"part_in_complx_rep\" )\n",
    "        if redundant_explaiantion: return explaining_object \n",
    "        complex_surface = compute_complex_surface_from_complex_surface_and_planar( rep_feature_1, \n",
    "                                                                                  rep_feature_2, \n",
    "                                                                                  knowledge_framework= knowledge_framework, \n",
    "                                                                                  physical_space=physical_space\n",
    "                                                                                   , new_complex_surface_name= name_rep)\n",
    " \n",
    "\n",
    "    elif knowledge_framework().Planar_Surface in rep_feature_1.is_a and  knowledge_framework().Planar_Surface in rep_feature_2.is_a :\n",
    "        redundant_explaiantion, explaining_object = rep_in_rep( physical_space, rep_feature_2, rep_feature_1, \n",
    "                                                                         feature2, feature1, use_case = \"part_in_part\" )\n",
    "        if redundant_explaiantion: return explaining_object \n",
    "\n",
    "        complex_surface = compute_complex_surface_two_planars(rep_feature_1, rep_feature_2, physical_space= physical_space,\n",
    "                                                              knowledge_framework= knowledge_framework  \n",
    "                                                            , complex_surface_name= name_rep )\n",
    "        \n",
    "\n",
    "    else:\n",
    "        raise MalissiaNotImplementedYet('explainable features representations are not Planar Surface or Complex_Surface') \n",
    "    \n",
    "\n",
    "    new_complex_surface = compute_larger_complex_surface(knowledge_framework, physical_space, complex_surface)\n",
    "    stratigraphic_part =  create_surface_part(knowledge_framework= knowledge_framework, \n",
    "                                             surface_representation= new_complex_surface, name = name_object, \n",
    "                                             explain = explainable_features)\n",
    "    \n",
    "    stratigraphic_part.has_Part = explainable_features\n",
    "    stratigraphic_part.has_Part.extend(explainable_features[0].has_Part)\n",
    "    stratigraphic_part.has_Part.extend(explainable_features[1].has_Part)\n",
    "\n",
    "    # temporary instruction to assign a rough center for the complex_surface, for representation, to be discussed\n",
    "    compute_center_complex_surface(knowledge_framework,physical_space, new_complex_surface)\n",
    "    if new_complex_surface.non_planar == True:  \n",
    "        stratigraphic_part.deformed = True\n",
    "    return stratigraphic_part\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def get_shared_sides_in_one_complex_surface(complex_surface, knowledge_framework, physical_space):\n",
    "    \"\"\"\n",
    "    Method to get shared sides in one complex surface. It returns list of shared sides. \n",
    "\n",
    "    Parameter:\n",
    "    - complex_surface : the complex_surface\n",
    "    - physical_space : the physical_space\n",
    "    - knowledge_framework : the knowledge_framework \n",
    "    \"\"\" \n",
    "\n",
    "    if len(complex_surface.has_Part)<2:\n",
    "        raise MalissiaBaseError('for a complex_surface to have a shared side in it, it must have at least two surface parts')\n",
    "    \n",
    "    neighbor_constructor_from_multiple_planars(complex_surface, knowledge_framework, physical_space)\n",
    "    list_of_shared_sides_in_complex_surf = []\n",
    "    for part in complex_surface.has_Part :\n",
    "        possible_nei = set(part.has_Neighbor).intersection(complex_surface.has_Part)\n",
    "        if possible_nei:\n",
    "            for neigh in list(possible_nei):\n",
    "                shared_intersection = set(neigh.has_Shared_Side).intersection(part.has_Shared_Side)\n",
    "                if shared_intersection is not None and list(shared_intersection)[0] not in list_of_shared_sides_in_complex_surf:\n",
    "                    list_of_shared_sides_in_complex_surf.append(list(shared_intersection)[0])\n",
    "    return list_of_shared_sides_in_complex_surf\n",
    "\n",
    "\n",
    "def get_unmatched_shared_sides_in_one_complex_surface(complex_surface, knowledge_framework, physical_space):\n",
    "    \"\"\"\n",
    "    Method to get unmatched shared sides in one complex surface. It returns list of unmatched shared sides. \n",
    "\n",
    "    Parameter:\n",
    "    - complex_surface : the complex_surface\n",
    "    - physical_space : the physical_space\n",
    "    - knowledge_framework : the knowledge_framework \n",
    "    \"\"\" \n",
    "\n",
    "    if len(complex_surface.has_Part)<2:\n",
    "        raise MalissiaBaseError('for a complex_surface to have a shared side in it, it must have at least two surface parts')\n",
    "    \n",
    "    neighbor_constructor_from_multiple_planars(complex_surface = complex_surface, knowledge_framework = knowledge_framework, physical_space = physical_space)\n",
    "    list_of_unmatched_shared_sides_in_complex_surf = []\n",
    "    for part in complex_surface.has_Part :\n",
    "        for unm_side in part.has_Unmatched_Shared_Side:\n",
    "            intersection_list = list(set(unm_side.has_Corresponding_Part).intersection(set(complex_surface.has_Part)))\n",
    "            if len(intersection_list) == 1 and unm_side not in list_of_unmatched_shared_sides_in_complex_surf: \n",
    "                list_of_unmatched_shared_sides_in_complex_surf.append(unm_side)\n",
    "\n",
    "    return list_of_unmatched_shared_sides_in_complex_surf\n",
    "\n",
    "\n",
    "def compute_normal_vector(nodes):\n",
    "    \"\"\"\n",
    "    Method to compute a normal vector from 4 nodes. \n",
    "\n",
    "    Parameter:\n",
    "    - nodes\n",
    "    \"\"\" \n",
    "    # Ensure we have four nodes\n",
    "    if len(nodes) != 4:\n",
    "        raise ValueError(\"A surface should be defined by four nodes.\")\n",
    "\n",
    "    # Define two vectors lying in the surface\n",
    "    vector1 = np.array(nodes[1]) - np.array(nodes[0])\n",
    "    vector2 = np.array(nodes[3]) - np.array(nodes[0])\n",
    "\n",
    "    # Compute the cross product to get the normal vector\n",
    "    normal_vector = np.cross(vector1, vector2)\n",
    "\n",
    "    # Normalize the normal vector to make it a unit vector\n",
    "    normal_vector /= np.linalg.norm(normal_vector)\n",
    "\n",
    "    return normal_vector\n",
    "\n",
    "\n",
    "def compute_planar_from_planar_complex_surface(complex_surface, knowledge_framework, physical_space):\n",
    "    \"\"\"\n",
    "    Method to compute a planar surface from a complex surface that is planar. \n",
    "        It returns a planar surface.\n",
    "\n",
    "    Parameter:\n",
    "    - complex_surface : the complex_surface\n",
    "    - physical_space : the physical_space\n",
    "    - knowledge_framework : the knowledge_framework \n",
    "    \"\"\" \n",
    "    # make sur that the complex_surface is planar\n",
    "    if complex_surface.non_planar != False:\n",
    "        raise MalissiaBaseError('the complex_surface {} does not have False value for the quality non_planar'.format(complex_surface))\n",
    "    if len(complex_surface.has_Part) != 2:\n",
    "        raise MalissiaNotImplementedYet('mehods to transform a complex_surface with n_parts > 2 parts into one palanr are not yet implemented')\n",
    "    shared_sides = get_shared_sides_in_one_complex_surface(complex_surface, knowledge_framework, physical_space)\n",
    "    if len(shared_sides) != 1:\n",
    "        raise MalissiaBaseError('the {} parts have {} shared sides, but it should be exactly 1'.format(complex_surface, len(shared_sides)))\n",
    "    \n",
    "    # other checking methods could be added like for normals parallelism and polarity\n",
    "    original_normal = physical_space.get_object_coordinates(complex_surface.has_Part[0], kind = \"normal\")\n",
    "\n",
    "    \n",
    "    shared = shared_sides[0]\n",
    "    size_shared = shared.size[0]\n",
    "    shared_points_list = [(physical_space.get_object_coordinates(shared.has_End_Points[0], \n",
    "                                                                kind = \"node\")[0]), \n",
    "                              (physical_space.get_object_coordinates(shared.has_End_Points[1], \n",
    "                                                                    kind = \"node\")[0])] \n",
    "    shared_points_tuple = [tuple(list_i)for list_i in shared_points_list]\n",
    "    ref_shared_point  = np.array(shared_points_list[0])\n",
    "\n",
    "    part1_nodes = physical_space.get_object_coordinates(complex_surface.has_Part[0], kind = \"nodes\")\n",
    "    part1_nodes_tuple = [tuple(list_i)for list_i in part1_nodes]\n",
    "    part1_extremeties = list(set(part1_nodes_tuple) - set(shared_points_tuple))\n",
    "    part1_size = np.linalg.norm(compute_point_projection_onto_line(np.array(part1_extremeties[0]),\n",
    "                                        np.array(shared_points_list[0]), \n",
    "                                     np.array(shared_points_list[0])-np.array(shared_points_list[1]))- part1_extremeties[0])\n",
    "    part1_extremeties_1 = np.array(part1_extremeties[0])\n",
    "    part1_extremeties_2 = np.array(part1_extremeties[1])\n",
    "    distance_to_point1_1 = np.linalg.norm(ref_shared_point - part1_extremeties_1)\n",
    "    distance_to_point1_2 = np.linalg.norm(ref_shared_point - part1_extremeties_2)\n",
    "\n",
    "    # Determine the most distant and closest points\n",
    "    most_distant_1 =  part1_extremeties_1 if distance_to_point1_1 > distance_to_point1_2 else part1_extremeties_2\n",
    "    closest_point_1 = part1_extremeties_1 if distance_to_point1_1 < distance_to_point1_2 else part1_extremeties_2\n",
    "    \n",
    "\n",
    "\n",
    "    part2_nodes = physical_space.get_object_coordinates(complex_surface.has_Part[1], kind = \"nodes\")\n",
    "    part2_nodes_tuple = [tuple(list_i)for list_i in part2_nodes]\n",
    "    part2_extremeties = list(set(part2_nodes_tuple) - set(shared_points_tuple))\n",
    "\n",
    "    part2_size = np.linalg.norm(compute_point_projection_onto_line(np.array(part2_extremeties[0]),\n",
    "                                        np.array(shared_points_list[0]), \n",
    "                                     np.array(shared_points_list[0])-np.array(shared_points_list[1]))- part2_extremeties[0])\n",
    "    \n",
    "\n",
    "    part2_extremeties_1 = np.array(part2_extremeties[0])\n",
    "    part2_extremeties_2 = np.array(part2_extremeties[1])\n",
    "    distance_to_point2_1 = np.linalg.norm(ref_shared_point - part1_extremeties_1)\n",
    "    distance_to_point2_2 = np.linalg.norm(ref_shared_point - part1_extremeties_2)\n",
    "\n",
    "    # Determine the most distant and closest points\n",
    "    most_distant_2 =  part2_extremeties_1 if distance_to_point2_1 > distance_to_point2_2 else part2_extremeties_2\n",
    "    closest_point_2 = part2_extremeties_1 if distance_to_point2_1 < distance_to_point2_2 else part2_extremeties_2\n",
    "\n",
    "    proposed_nodes = np.array([most_distant_2, closest_point_2, closest_point_1, most_distant_1])\n",
    "    proposed_nodes_normal = compute_normal_vector(proposed_nodes)\n",
    "    if are_parallel_and_same_direction(proposed_nodes_normal, original_normal):\n",
    "        nodes_tempo = proposed_nodes\n",
    "    else:\n",
    "        nodes_tempo = np.array([most_distant_1, closest_point_1, closest_point_2, most_distant_2])\n",
    "        proposed_nodes_normalx = compute_normal_vector(nodes_tempo)\n",
    "        # recheck to make sure\n",
    "        if not are_parallel_and_same_direction(proposed_nodes_normalx, original_normal): \n",
    "            raise MalissiaBaseError('can not compute complex_surface from exsiting nodes {}, check their order'.format(nodes_tempo))\n",
    "     \n",
    "    coor_lab = physical_space.coordinate_labels\n",
    "    nb_points = len(knowledge_framework().Point.instances())\n",
    "    new_planar_nodes = [\n",
    "        constructor_point(knowledge_framework,coor_lab ,\n",
    "                          [float(x) for x in nodes_tempo[0]], \n",
    "                          name= \"point_nb_{}_N0\".format(nb_points+1)),\n",
    "        constructor_point(knowledge_framework,coor_lab ,\n",
    "                          [float(x) for x in nodes_tempo[1]], \n",
    "                          name= \"point_nb_{}_N1\".format(nb_points+2)),\n",
    "        constructor_point(knowledge_framework,coor_lab ,\n",
    "                          [float(x) for x in nodes_tempo[2]], \n",
    "                          name= \"point_nb_{}_N2\".format(nb_points+3)),\n",
    "        constructor_point(knowledge_framework,coor_lab ,\n",
    "                          [float(x) for x in nodes_tempo[3]], \n",
    "                          name= \"point_nb_{}_N3\".format(nb_points+4)),                  \n",
    "        ]\n",
    "    return constructor_planar_surface_from_nodes(knowledge_framework, new_planar_nodes)\n",
    "\n",
    "\n",
    "def compute_center_complex_surface(knowledge_framework, physical_space, complex_surface, \n",
    "                                   extreme_faces = None, force_computing_for_fold = False,\n",
    "                                     assign_center_to_complex_surface = True,):\n",
    "    \"\"\"\n",
    "    Method to compute and attributting a center of complex surface. \n",
    "        It returns the midpoint between the centers of the two extreme faces. \n",
    "\n",
    "    Parameter:\n",
    "    - complex_surface : the complex_surface\n",
    "    - physical_space : the physical_space\n",
    "    - knowledge_framework : the knowledge_framework \n",
    "    \"\"\" \n",
    "    if force_computing_for_fold == True:\n",
    "       faces = extreme_faces\n",
    "       assign_center_to_complex_surface = False\n",
    "    else: \n",
    "        if len(complex_surface.has_Part )< 2 :\n",
    "            raise MalissiaBaseError('the complex surface should have > 2 parts') \n",
    "        else: \n",
    "            faces =  complex_surface.has_Part\n",
    "    center = np.mean([np.array(physical_space.get_object_coordinates(face_i, \"center\")) for face_i in faces \\\n",
    "                       if physical_space.get_object_coordinates(face_i, \"center\") is not None ], axis = 0)\n",
    "\n",
    "    if assign_center_to_complex_surface:\n",
    "        center_formated =  constructor_point(knowledge_framework, physical_space.coordinate_labels, [float(n_i) for n_i in center])\n",
    "        complex_surface.has_Center = [center_formated]\n",
    "    return center\n",
    "    \n",
    "\n",
    "def compute_size_complex_surface_for_representation(knowledge_framework, physical_space, complex_surface, extreme_faces = None):\n",
    "    \"\"\"\n",
    "    Method to compute a rough size of a complex_surface or a fold for representation and projection of explained objects.\n",
    "     It returns the distance between the farthest nodes of the extreme nodes of the complex_surface.\n",
    "\n",
    "    Parameter:\n",
    "    - extreme_faces : extreme faces of the complex_surface if already identified\n",
    "    - complex_surface : the complex_surface\n",
    "    - physical_space : the physical_space\n",
    "    - knowledge_framework : the knowledge_framework \n",
    "    \"\"\" \n",
    "    extreme_faces = compute_complex_surface_extreme_surfaces(knowledge_framework, \n",
    "                            complex_surface, return_none= True) if extreme_faces is None else extreme_faces\n",
    "    if extreme_faces is None: # temporary solution to avoid representation broking\n",
    "        return complex_surface.has_Part[0].size[0]\n",
    "    if len(extreme_faces) != 2:\n",
    "        raise MalissiaBaseError('problm with calculating extreme faces')\n",
    "    extremeties = compute_extremeties_from_two_extreme_surfaces(extreme_faces, physical_space)\n",
    "    if len(extremeties) != 2:\n",
    "        raise MalissiaBaseError('problm with calculating extremeties')\n",
    "    node1 = np.array([\n",
    "        extremeties[0][0]])\n",
    "    nodes = [extremeties[1][0],\n",
    "        extremeties[1][1],]\n",
    "    farthest = np.array(find_farthest_node_from_nodes(nodes, node1))\n",
    "    size =  float(np.round(np.linalg.norm(node1 - farthest), 2))\n",
    "    return size\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Updated complex_surface"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def anomaly_type(knowledge_framework, anomaly):\n",
    "    anomaly_type = list(set(anomaly.is_a).intersection(set(knowledge_framework().Anomaly.subclasses())))\n",
    "    if len(anomaly_type) != 1:\n",
    "        raise MalissiaBaseError('the introduced anomaly has more then one type: {}'.format(anomaly.name, anomaly_type))\n",
    "    else: return anomaly_type[0]\n",
    "    \n",
    "\n",
    "def updated_complex_surface_constructor_after_anomaly(knowledge_framework, physical_space, anomaly, anomaly_type ):\n",
    "    if anomaly_type != knowledge_framework().ComplexSurfaceSizeSharedSidesAnomaly:\n",
    "        raise MalissiaNotImplementedYet('constructor for anomaly type {} not implemented yet'.format(anomaly_type.name))\n",
    "    complex_surface = anomaly.is_Related_To[0]\n",
    "    return compute_larger_complex_surface(knowledge_framework, physical_space, complex_surface)\n",
    "\n",
    "\n",
    "\n",
    "def compute_larger_complex_surface(knowledge_framework, physical_space, complex_surface):\n",
    "    if shared_sides_are_equal(complex_surface  = complex_surface, knowledge_framework  = knowledge_framework, \n",
    "                            physical_space =  physical_space) == True \\\n",
    "                         and  shared_sides_have_uniform_allignement(complex_surface  = complex_surface, \n",
    "                             knowledge_framework  = knowledge_framework, physical_space =  physical_space) == True:\n",
    "        return complex_surface\n",
    "    \n",
    "\n",
    "    shared_sides = get_shared_sides_in_one_complex_surface(complex_surface, knowledge_framework, physical_space)\n",
    "    unmatched_sides = get_unmatched_shared_sides_in_one_complex_surface(complex_surface, knowledge_framework, physical_space)\n",
    "    sides = shared_sides + unmatched_sides\n",
    "    if len(sides) < 1 :\n",
    "        raise MalissiaBaseError ('Warning: there is no shared sides or unmatched sides with complex_surface {}'.format(complex_surface.name))\n",
    "    \n",
    "\n",
    "    init_size = -1\n",
    "    reference_side = None\n",
    "    for side_i in sides:\n",
    "        if side_i.size[0] > init_size:\n",
    "            reference_side = side_i\n",
    "            init_size = side_i.size[0]\n",
    "\n",
    "    p_0_side = physical_space.get_object_coordinates(reference_side.has_End_Points[0], \"node\")[0]\n",
    "    p_1_side = physical_space.get_object_coordinates(reference_side.has_End_Points[1], \"node\")[0]\n",
    "    reference_vec = np.array(p_0_side)-np.array(p_1_side)\n",
    "    projected_sides_nodes = []\n",
    "\n",
    "    for side_i in sides :\n",
    "        side_i_p0 =  np.array(physical_space.get_object_coordinates(side_i.has_End_Points[0], \"node\")[0])\n",
    "        side_i_p1 = np.array(physical_space.get_object_coordinates(side_i.has_End_Points[1], \"node\")[0])\n",
    "\n",
    "        projected_sides_nodes.append(compute_point_projection_onto_line(side_i_p0, p_0_side, reference_vec))\n",
    "        projected_sides_nodes.append(compute_point_projection_onto_line(side_i_p1, p_0_side, reference_vec))\n",
    "\n",
    "    info = compute_projection_info (projected_sides_nodes,  reference_vec)\n",
    "    node_of_extension_1 = info['start_point'] \n",
    "    node_of_extension_2 = info['end_point'] \n",
    "    \n",
    "\n",
    "    new_complex_surface = compute_larger_complex_surface_from_complex_surface_laterally(complex_surface, \n",
    "                                                                    node_of_extension_1, knowledge_framework, physical_space)\n",
    "\n",
    "    if shared_sides_are_equal(complex_surface  = new_complex_surface, knowledge_framework  = knowledge_framework, \n",
    "                                         physical_space =  physical_space)== True \\\n",
    "                and  shared_sides_have_uniform_allignement (complex_surface  = new_complex_surface,\n",
    "                                                            knowledge_framework  = knowledge_framework, \n",
    "                                                           physical_space =  physical_space) == True:\n",
    "        return new_complex_surface\n",
    "    \n",
    "    else:\n",
    "        return compute_larger_complex_surface_from_complex_surface_laterally(new_complex_surface, node_of_extension_2 \n",
    "                                                                             ,knowledge_framework, physical_space)\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def common_two_nodes_two_planars(nodes1, nodes2, return_error = True):\n",
    "    \"\"\"\n",
    "    Method to extract common two nodes of two planars if exsist.\n",
    "    It return a list of two shared nodes if they are found, else it returns an error. In case return_error == False, \n",
    "        the method will return a none type if nothing is found. \n",
    "\n",
    "    Parameter:\n",
    "    - nodes1, nodes2 : lists of nodes of the two planars\n",
    "    - return_error : boolean by default is True. If False, the method returns None object\n",
    "    \"\"\" \n",
    "    if type(nodes1) != list:\n",
    "        nodes1 = nodes1.tolist()\n",
    "    if type(nodes2) != list:\n",
    "        nodes2 = nodes2.tolist()\n",
    "\n",
    "    common_nodes = [node_i for node_i in nodes1 if node_i in nodes2]\n",
    "    if len(common_nodes) == 2:\n",
    "        return common_nodes \n",
    "    else:\n",
    "        if return_error == True :\n",
    "            raise MalissiaBaseError('there is {} common nodes '.format(len(common_nodes)))\n",
    "        else: \n",
    "            return None\n",
    "    \n",
    "def project_point_onto_plane(point, vertices):\n",
    "    \"\"\"\n",
    "    Method to project a point on a plane defined by its vertices. It returns an np.array [x,y,z] of the projected point.\n",
    "\n",
    "    Parameter:\n",
    "    - point : point to be projected\n",
    "    - vertices : vertices of the surface hold by the plane on which the point will be projected\n",
    "    \"\"\" \n",
    "    # Find two vectors within the plane\n",
    "    vector1 = vertices[1] - vertices[0]\n",
    "    vector2 = vertices[3] - vertices[0]\n",
    "\n",
    "    # Calculate the normal vector to the plane\n",
    "    normal_vector = np.cross(vector1, vector2)\n",
    "\n",
    "    # Calculate the projection of the point onto the plane\n",
    "    projection = point - np.dot(point - vertices[0], normal_vector) / np.dot(normal_vector, normal_vector) * normal_vector\n",
    "\n",
    "    return projection\n",
    "\n",
    "\n",
    "def multiple_parts_constructor_for_complex_surface(knowledge_framework, new_complex_surface,\n",
    "                                                                 physical_space, list__of_parts_nodes):\n",
    "    \"\"\"\n",
    "    Method to construct multiple parts in a complex surface. It returns a list of constructed parts\n",
    "    \n",
    "\n",
    "    Parameter:\n",
    "    - knowledge_framework : the knowledge_framework\n",
    "    - new_complex_surface : the new complex_surface\n",
    "    - physical_space : the physical_space\n",
    "    - list__of_parts_nodes : list of parts nodes that will be construced\n",
    "    \"\"\" \n",
    "    constructed_parts = []\n",
    "    \n",
    "    if len(list__of_parts_nodes) == 0 :\n",
    "        return new_complex_surface\n",
    "    for nodes_i in list__of_parts_nodes:\n",
    "        nb_nodes = len(knowledge_framework().Point.instances())\n",
    "        nb_parts = len(knowledge_framework().Planar_Surface.instances())\n",
    "        name_of_part = 'part_{}'.format(nb_parts+1)\n",
    "        nodes= [constructor_point(knowledge_framework, physical_space.coordinate_labels, nodes_i[0], name=\"N_nb_{}\".format(nb_nodes+1)),\n",
    "                constructor_point(knowledge_framework, physical_space.coordinate_labels, nodes_i[1], name=\"N_nb_{}\".format(nb_nodes+2)),\n",
    "                constructor_point(knowledge_framework, physical_space.coordinate_labels, nodes_i[2], name=\"N_nb_{}\".format(nb_nodes+3)),\n",
    "                constructor_point(knowledge_framework, physical_space.coordinate_labels, nodes_i[3], name=\"N_nb_{}\".format(nb_nodes+4))]\n",
    "        x_part = constructor_planar_surface_from_nodes(knowledge_framework, nodes, name= name_of_part)\n",
    "        new_complex_surface.has_Part.append(x_part)\n",
    "        constructed_parts.append(x_part)\n",
    "    neighbor_constructor_from_multiple_planars(new_complex_surface, knowledge_framework, physical_space )\n",
    "    return constructed_parts\n",
    "    \n",
    "def find_farthest_node_from_nodes(nodes, proposed_node_of_extension):\n",
    "    \"\"\"\n",
    "    Method to find the farthest point amongest a list of nodes from a referene point 'proposed_node_of_extension'. \n",
    "        it returns an np.array [x,y,z] of the farthest node.\n",
    "    \n",
    "    Parameter:\n",
    "    - nodes : nodes\n",
    "    - proposed_node_of_extension : proposed_node_of_extension\n",
    "    \"\"\" \n",
    "    return max(nodes, key=lambda node_i: np.linalg.norm(np.array(node_i) - np.array(proposed_node_of_extension)))\n",
    "\n",
    "\n",
    "def is_point_on_line_projection(point, line_start, line_end, tolerance=0.1):\n",
    "    \"\"\"\n",
    "    Method to find if a point projection is on a line segment. It returns a True or False Value.\n",
    "    \n",
    "    Parameter:\n",
    "    - point : point to be projected and tested\n",
    "    - line_start, line_end : points that define the line segment\n",
    "    - tolerance : a small value to account for numerical imprecision\n",
    "    \"\"\" \n",
    "    point = np.array(point)\n",
    "    line_start = np.array(line_start)\n",
    "    line_end = np.array(line_end)\n",
    "    \n",
    "    \n",
    "    \n",
    "    # Calculate the projection of the point onto the line\n",
    "    projection = line_start + np.dot(point - line_start, \n",
    "                                     line_end - line_start) / np.linalg.norm(line_end \\\n",
    "                                                                             - line_start)**2 * (line_end - line_start)\n",
    "    if np.round(np.linalg.norm(projection - line_start),1) <= tolerance :\n",
    "        return True\n",
    "    if np.round(np.linalg.norm(projection - line_end),1) <= tolerance :\n",
    "        return True\n",
    "    # Check if the projection lies on the line segment with tolerance\n",
    "    on_segment = 0 <= np.dot(projection - line_start, line_end - line_start) \\\n",
    "                            <= np.linalg.norm(line_end - line_start)**2 + tolerance\n",
    "    \n",
    "    return on_segment\n",
    "\n",
    "def vectors_size_is_equal_for_surface_upgrade(oldv1_mag, oldv2_mag, newv1_mag, newv2_mag):\n",
    "    oldv1_mag = np.round(oldv1_mag, 3)\n",
    "    oldv2_mag = np.round(oldv2_mag, 3)\n",
    "    newv1_mag = np.round(newv1_mag, 3)\n",
    "    newv2_mag = np.round(newv2_mag, 3)\n",
    "    return newv1_mag == oldv1_mag or newv2_mag == oldv2_mag\n",
    "\n",
    "def check_vectors_size_for_surface_upgrade(oldv1_mag, oldv2_mag, newv1_mag, newv2_mag):\n",
    "    \"\"\"\n",
    "    Method to check that new vectors 'two sides' of a new surface are greater then the old ones. \n",
    "    It returns True or false value. three cases are accepted and give a True value:\n",
    "        if the two vectors are greater then the old ones\n",
    "        one of the vectors is greater is the other one is at least equal to the old one\n",
    "        one vector is greater in the other vector is null. \n",
    "\n",
    "    Parameter:\n",
    "    - oldv1_mag : old_vector 1 magnitude\n",
    "    - oldv2_mag : old_vector 2 magnitude\n",
    "    - newv1_mag : new_vector 1 magnitude\n",
    "    - newv2_mag : new_vector 2 magnitude \n",
    "    \"\"\" \n",
    "    oldv1_mag = np.round(oldv1_mag, 3)\n",
    "    oldv2_mag = np.round(oldv2_mag, 3)\n",
    "    newv1_mag = np.round(newv1_mag, 3)\n",
    "    newv2_mag = np.round(newv2_mag, 3)\n",
    "    # Check if both new vectors are greater than or equal to the old vectors\n",
    "    condition1 = newv1_mag >= oldv1_mag  and newv2_mag >= oldv2_mag\n",
    "    condition2 = newv1_mag == oldv1_mag and newv2_mag == oldv2_mag\n",
    "\n",
    "    # Check if one new vector has a magnitude of 0 while the other is greater than the old one\n",
    "    condition3 = newv1_mag == 0 and newv2_mag > oldv2_mag or newv2_mag == 0 and newv1_mag > oldv1_mag\n",
    "    if (condition1 == True and condition2 == False) or condition3 == True:\n",
    "        return True\n",
    "    #temporary fix (todo must treat topology of nodes)\n",
    "    ratio1 = np.round(newv1_mag/newv2_mag, 1)\n",
    "    ratio2 = np.round(newv2_mag/newv1_mag, 1)\n",
    "\n",
    "    condition4 = ratio1 == 0 and newv2_mag > oldv2_mag or ratio2 == 0 and newv1_mag > oldv1_mag\n",
    "    if  condition4:\n",
    "        return True\n",
    "    # end of the fix \n",
    "\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "def check_point_location_for_surface_upgrade(vector_of_projection, vector_0_1, vector_0_3):\n",
    "    \"\"\"\n",
    "    Method to check if the point of extension is located in the inner side of the surface to be upgraded or outside.\n",
    "        It returns It returns True or false value. \n",
    "\n",
    "    Parameter:\n",
    "    - vector_of_projection : the vector of projection point of extension -point to fix\n",
    "    - vector_0_1 : vector from nodes 0 to 1 of the surface to be extended 0 is the node to fix\n",
    "    - vector_0_3 : vector from nodes 0 to 3 of the surface to be extended 0 is the node to fix\n",
    "    \"\"\" \n",
    "    condition1 = np.round(np.dot(vector_of_projection, vector_0_1), 3) >= 0\n",
    "    condition2 = np.round(np.dot(vector_of_projection, vector_0_3), 3) >= 0\n",
    "    return condition1 and condition2\n",
    "    \n",
    "def compute_larger_surface_by_extension(node0, node1, node2, node3,\n",
    "                                         node_to_fix, proposed_node_of_extension,\n",
    "                                        force_axis_direction = None):\n",
    "    \"\"\"\n",
    "    Method to extend a surface based on a point that must be located outside the existing surface and the vector from \n",
    "        the node to fix to the node of extension must point to the inner part of the surface 'between the two vectors that define\n",
    "        the surface and start at the point_to_fix' \n",
    "    if needed, the extension could be forced on a given axis, in this case, an axis in force_axis_direction must be given\n",
    "    Parameters:\n",
    "    - node0, node1, node2, node3 : four nodes of the surface to be extended.\n",
    "    - node_to_fix : the node to fix \n",
    "    - proposed_node_of_extension : the proposed_node_of_extension\n",
    "    - force_axis_direction = by default is None, or it could takes the type of an np.array[x,y,z] of a vector.\n",
    "    \"\"\"\n",
    "    \n",
    "    if force_axis_direction is not None:\n",
    "        force_axis_direction /= np.linalg.norm(force_axis_direction)\n",
    "    nodes = np.array([node0, node1, node2, node3])\n",
    "    for i, node in enumerate(nodes):\n",
    "        if np.array_equal(node, node_to_fix): # Check if the current node matches the node_to_fix\n",
    "            # If so, set new_node_x and new_node_y accordingly\n",
    "            modified_node_3 = nodes[(i - 1) % 4]  # Previous node\n",
    "            modified_node_1 = nodes[(i + 1) % 4]  # Next node\n",
    "            modified_node_0 = node\n",
    "            modified_node_2 = nodes[(i + 2) % 4] \n",
    "\n",
    "            vector_0_1 = modified_node_1 - modified_node_0 \n",
    "            side_0_1 = np.linalg.norm(vector_0_1)\n",
    "            vector_0_1/= side_0_1\n",
    "            vector_0_3 = modified_node_3 - modified_node_0 \n",
    "            side_0_3 = np.linalg.norm(vector_0_3)\n",
    "            vector_0_3/= side_0_3\n",
    "\n",
    "            # check the vector of extension is not pointing out outside the surface            \n",
    "            vector_of_extension = np.array(proposed_node_of_extension)- np.array(node_to_fix)\n",
    "            check_orientation_condtion = check_point_location_for_surface_upgrade( vector_of_extension, vector_0_1, vector_0_3)\n",
    "            if check_orientation_condtion == False:\n",
    "                raise  MalissiaBaseError(' the vector from point_to_fix to the projected point is pointing outside the surface')\n",
    "            # check that the point of extension is on the same plane as the surface                                                                  \n",
    "            vector_of_extension_normalized = vector_of_extension / np.linalg.norm(vector_of_extension)\n",
    "            cross_p_surface_axis = (np.cross(vector_0_1, vector_0_3)) / np.linalg.norm(np.cross(vector_0_1, vector_0_3)) \n",
    "            cross_p_axis_1_proj = (np.cross(vector_0_1, vector_of_extension_normalized)) / np.linalg.norm(np.cross(vector_0_1, vector_of_extension_normalized))\n",
    "            if all(cross_p_surface_axis != cross_p_axis_1_proj) and np.round(np.linalg.norm(np.cross(vector_0_1, vector_of_extension_normalized)),3) !=0:\n",
    "\n",
    "                raise  MalissiaBaseError(' the projected point is not on the same plane that bears the candidate surface')\n",
    "            \n",
    "            if force_axis_direction is None :\n",
    "                projection_on_vector_0_1 = compute_point_projection_onto_line(proposed_node_of_extension,\n",
    "                                                                            modified_node_0,  vector_0_1)\n",
    "                vec_to_projection_on_vector_0_1 = projection_on_vector_0_1 - modified_node_0\n",
    "                vec_to_projection_on_vector_0_1_mag = np.linalg.norm(vec_to_projection_on_vector_0_1)\n",
    "                if vec_to_projection_on_vector_0_1_mag != 0:\n",
    "                    vec_to_projection_on_vector_0_1/=vec_to_projection_on_vector_0_1_mag\n",
    "\n",
    "                projection_on_vector_0_3 = compute_point_projection_onto_line(proposed_node_of_extension,\n",
    "                                                                            modified_node_0,  vector_0_3)\n",
    "                vec_to_projection_on_vector_0_3 = projection_on_vector_0_3 - modified_node_0\n",
    "                vec_to_projection_on_vector_0_3_mag = np.linalg.norm(vec_to_projection_on_vector_0_3)\n",
    "                if vec_to_projection_on_vector_0_3_mag != 0:\n",
    "                    vec_to_projection_on_vector_0_3 /= vec_to_projection_on_vector_0_3_mag\n",
    "\n",
    "            elif np.round(np.dot(force_axis_direction, vector_0_1), 2) == 1:\n",
    "                projection_on_vector_0_1 = compute_point_projection_onto_line(proposed_node_of_extension,\n",
    "                                                            modified_node_0,  vector_0_1)\n",
    "                vec_to_projection_on_vector_0_1 = projection_on_vector_0_1 - modified_node_0\n",
    "                vec_to_projection_on_vector_0_1_mag = np.linalg.norm(vec_to_projection_on_vector_0_1)\n",
    "                vec_to_projection_on_vector_0_1/=vec_to_projection_on_vector_0_1_mag\n",
    "                projection_on_vector_0_3 = modified_node_0\n",
    "                vec_to_projection_on_vector_0_3 = np.array([0.,0.,0.])\n",
    "                vec_to_projection_on_vector_0_3_mag = 0.\n",
    "\n",
    "            elif np.round(np.dot(force_axis_direction, vector_0_3), 2) == 1:\n",
    "                projection_on_vector_0_3 = compute_point_projection_onto_line(proposed_node_of_extension,\n",
    "                                                            modified_node_0,  vector_0_3)\n",
    "                vec_to_projection_on_vector_0_3 = projection_on_vector_0_3 - modified_node_0\n",
    "                vec_to_projection_on_vector_0_3_mag = np.linalg.norm(vec_to_projection_on_vector_0_3)\n",
    "                vec_to_projection_on_vector_0_3/=vec_to_projection_on_vector_0_3_mag\n",
    "\n",
    "                projection_on_vector_0_1 = modified_node_0\n",
    "                vec_to_projection_on_vector_0_1 = np.array([0.,0.,0.])\n",
    "                vec_to_projection_on_vector_0_1_mag = 0.  \n",
    "\n",
    "            elif  np.round(np.dot(force_axis_direction, vector_0_3), 3) == -1 or np.round(np.dot(force_axis_direction, vector_0_1), 3) == -1:\n",
    "                raise MalissiaBaseError('the forced vector starting from the point_to_fix is pointing outside the surface \"must be in the opposite direction\" ')    \n",
    "            else:\n",
    "                raise MalissiaBaseError(' forced vector starting from the point_to_fix must be parallel  at least to one side of the surface')\n",
    "            \n",
    "            check_size_condtions = check_vectors_size_for_surface_upgrade(side_0_1, side_0_3, \n",
    "                                                 vec_to_projection_on_vector_0_1_mag, \n",
    "                                                 vec_to_projection_on_vector_0_3_mag)\n",
    "            \n",
    "            if check_size_condtions == False:\n",
    "                raise MalissiaBaseError('the proposed extension must be larger than the existing surface, at least on one side, and must not truncate the existing one')\n",
    "            else:\n",
    "                if np.round(vec_to_projection_on_vector_0_1_mag,3) == 0:\n",
    "                    new_node_0 = [float(i) for i in modified_node_0]\n",
    "                    new_node_1 = [float(i) for i in modified_node_1] \n",
    "                    new_node_2 = compute_endpoint(new_node_1, vec_to_projection_on_vector_0_3, \n",
    "                                              vec_to_projection_on_vector_0_3_mag)\n",
    "                    new_node_2 = [float(i) for i in new_node_2]  \n",
    "                    new_node_3 = [float(i) for i in projection_on_vector_0_3] \n",
    "                    return np.array([new_node_0, new_node_1, new_node_2, new_node_3])\n",
    "\n",
    "                if np.round(vec_to_projection_on_vector_0_3_mag,3)  == 0:\n",
    "                    new_node_0 = [float(i) for i in modified_node_0]\n",
    "                    new_node_1 = [float(i) for i in projection_on_vector_0_1] \n",
    "                    new_node_3 = [float(i) for i in modified_node_3] \n",
    "                    new_node_2 = compute_endpoint(new_node_3, vec_to_projection_on_vector_0_1, \n",
    "                                              vec_to_projection_on_vector_0_1_mag)\n",
    "                    new_node_2 = [float(i) for i in new_node_2]\n",
    "\n",
    "                    return np.array([new_node_0, new_node_1, new_node_2, new_node_3])\n",
    "                else:\n",
    "                    new_node_0 = [float(i) for i in modified_node_0]\n",
    "                    new_node_1 = [float(i) for i in projection_on_vector_0_1] \n",
    "                    new_node_2 = [float(i) for i in proposed_node_of_extension] \n",
    "                    new_node_3 =  [float(i) for i in projection_on_vector_0_3] \n",
    "                    return np.array([new_node_0, new_node_1, new_node_2, new_node_3])\n",
    "                   \n",
    "            break  # Exit the loop if a match is found\n",
    "    else:\n",
    "        raise MalissiaBaseError(\"node_to_fix not in the surface nodes\")\n",
    "    \n",
    "\n",
    "\n",
    "def compute_larger_complex_surface_from_complex_surface_laterally(complex_surface, node_of_extension,\n",
    "                                                                   knowledge_framework, physical_space, tolerance = 0.5,\n",
    "                                                                   new_complex_surface = None, ):\n",
    "    \n",
    "\n",
    "    neighbor_constructor_from_multiple_planars(complex_surface, knowledge_framework, physical_space)\n",
    "    parts = complex_surface.has_Part\n",
    "    if len(parts) < 2:\n",
    "        raise MalissiaBaseError('complex_surface {} has {} parts, maybe try method: compute_larger_surface_by_extension'.fromat(complex_surface.name, \n",
    "                                                                                                                                len(parts)))\n",
    "    node_of_extension = np.array(node_of_extension)\n",
    "    shared_sides = get_shared_sides_in_one_complex_surface(complex_surface, knowledge_framework, physical_space)\n",
    "    unmathced_sides = get_unmatched_shared_sides_in_one_complex_surface(complex_surface, knowledge_framework, physical_space)\n",
    "    sides = shared_sides + unmathced_sides \n",
    "    if len(sides) < 1 :\n",
    "        print('Warning: complex_surface {} parts have no shared or unmatched sides'.format(complex_surface.name))\n",
    "        return None\n",
    "    \n",
    "    if new_complex_surface is None:\n",
    "        nb_of_cplx_sur = len(knowledge_framework().Complex_Surface.instances())\n",
    "        new_complex_surface_name = str('cplx_sur_nb_{}'.format(nb_of_cplx_sur+1))\n",
    "        new_complex_surface = knowledge_framework().Complex_Surface(name = new_complex_surface_name, non_planar = True)\n",
    "\n",
    "    unchanged_parts = []\n",
    "    extended_parts = []\n",
    "    new_parts_nodes = []\n",
    "    for side_i in shared_sides:\n",
    "        start_point = physical_space.get_object_coordinates(side_i.has_End_Points[0], \"node\")[0]\n",
    "        end_point = physical_space.get_object_coordinates(side_i.has_End_Points[1], \"node\")[0]\n",
    "        vec_shared_side = np.array(start_point)-np.array(end_point)\n",
    "        projected_node_on_vec = compute_point_projection_onto_line(node_of_extension, start_point, vec_shared_side)\n",
    "        node_to_fix = find_farthest_node_from_nodes([start_point, end_point], projected_node_on_vec)\n",
    "        closest_point = start_point if set(end_point) == set(node_to_fix) else end_point\n",
    "        \n",
    "        # temporary fix (todo : work on topolgy of common nodes)\n",
    "        if np.linalg.norm(np.array(closest_point) - np.array(projected_node_on_vec)) <= tolerance:\n",
    "            for part in side_i.is_Shared_Side_Of:\n",
    "                if part not in unchanged_parts:\n",
    "                    unchanged_parts.append(part)\n",
    "        # end of the fix           \n",
    "        if set(closest_point) == set(projected_node_on_vec):\n",
    "            for part in side_i.is_Shared_Side_Of:\n",
    "                if part not in unchanged_parts:\n",
    "                    unchanged_parts.append(part)\n",
    "        if not is_point_on_line_projection(projected_node_on_vec, start_point, end_point):\n",
    "            for part_i in side_i.is_Shared_Side_Of:\n",
    "                if part_i not in extended_parts :\n",
    "                    part_i_nodes = physical_space.get_object_coordinates(part_i, \"nodes\")\n",
    "                    new_part_nodes = compute_larger_surface_by_extension(*part_i_nodes, node_to_fix, projected_node_on_vec)\n",
    "                    extended_parts.append(part_i)\n",
    "                    new_parts_nodes.append(new_part_nodes)\n",
    "\n",
    "    for unma_side_i in unmathced_sides:\n",
    "        start_point = physical_space.get_object_coordinates(unma_side_i.has_End_Points[0], \"node\")[0]\n",
    "        end_point = physical_space.get_object_coordinates(unma_side_i.has_End_Points[1], \"node\")[0]\n",
    "        vec_shared_side = np.array(start_point)-np.array(end_point)\n",
    "        projected_node_on_vec = compute_point_projection_onto_line(node_of_extension, start_point, vec_shared_side)\n",
    "        node_to_fix = find_farthest_node_from_nodes([start_point, end_point], projected_node_on_vec)\n",
    "        closest_point = start_point if set(end_point) == set(node_to_fix) else end_point\n",
    "\n",
    "        # temporary fix (todo : work on topolgy of common nodes)\n",
    "        if np.linalg.norm(np.array(closest_point) - np.array(projected_node_on_vec)) <= tolerance:\n",
    "            for part in side_i.is_Shared_Side_Of:\n",
    "                if part not in unchanged_parts:\n",
    "                    unchanged_parts.append(part)\n",
    "        # end of the fix      \n",
    "                                  \n",
    "        if set(closest_point) == set(projected_node_on_vec):\n",
    "            for part in side_i.is_Unmatched_Shared_Side_Of:\n",
    "                if part not in unchanged_parts:\n",
    "                    unchanged_parts.append(part)\n",
    "        if not is_point_on_line_projection(projected_node_on_vec, start_point, end_point):\n",
    "            for part_i in unma_side_i.is_Unmatched_Shared_Side_Of:\n",
    "                if part_i not in extended_parts :\n",
    "                    part_i_nodes = physical_space.get_object_coordinates(part_i, \"nodes\")\n",
    "                    new_part_nodes = compute_larger_surface_by_extension(*part_i_nodes, node_to_fix, projected_node_on_vec)\n",
    "                    extended_parts.append(part_i)\n",
    "                    new_parts_nodes.append(new_part_nodes)\n",
    "    \n",
    "    for part_i in parts:\n",
    "        if part_i not in extended_parts and part_i not in unchanged_parts:\n",
    "            unchanged_parts.append(part_i)\n",
    "    multiple_parts_constructor_for_complex_surface(knowledge_framework, new_complex_surface,physical_space, new_parts_nodes)\n",
    "    new_complex_surface.has_Part.extend(unchanged_parts)\n",
    "\n",
    "    neighbor_constructor_from_multiple_planars(complex_surface=  new_complex_surface, \n",
    "                                               knowledge_framework= knowledge_framework, physical_space= physical_space )\n",
    "    attribute_parts_nodes_to_complex_surface(new_complex_surface)\n",
    "\n",
    "    return new_complex_surface\n",
    "\n",
    "\n",
    "\n",
    "# methods to be updated (porblem with neighbors successions)\n",
    "def compute_larger_surface_by_extension_of_two_non_planars_complex_surface(knowledge_framework,\n",
    "                                                                                 physical_space, \n",
    "                                                                                 first_face_to_extend, \n",
    "                                                                                 second_face_to_extend, \n",
    "                                                           node_to_fix, proposed_node_of_extension, \n",
    "                                                           new_complex_surface = None, force_axis = None,\n",
    "                                                             force_projection_of_point_on_part1_plane = True, \n",
    "                                                              force_construction_of_first_part = True ):\n",
    "    \"\"\"\n",
    "    Method to extend create a ne complex surface by the extension of an exsiting non_planar complex_surface that has two parts.\n",
    "        The extension coild ne forced on an axis. The point of extension could be projected at the plane of the first face to extend if needed.\n",
    "        The method could construct both new parts, or only one and leave the first part. It returns a new_complex_surface.\n",
    "    Parameter:\n",
    "    - complex_surface : the complex_surface\n",
    "    - physical_space : the physical_space\n",
    "    - first_face_to_extend : first_face_to_extend\n",
    "    - second_face_to_extend : second_face_to_extend\n",
    "    - node_to_fix : node_to_fix\n",
    "    - proposed_node_of_extension : proposed_node_of_extension \n",
    "    - new_complex_surface : new_complex_surface\n",
    "    - force_axis : by default is None, or it could takes the type of an np.array[x,y,z] of a vector.\n",
    "    - coord_labels : coord_labels\n",
    "    - force_projection_of_point_on_part1_plane : boolean by default True. If True it forces the projection of the node of extension on the first plane to extend\n",
    "    - force_construction_of_first_part : boolean by default True. If True, it forces the construction of new part_1 and not using the existing part\n",
    "    \"\"\" \n",
    "    if new_complex_surface == None : \n",
    "        nb = len(knowledge_framework().Complex_Surface.instances())\n",
    "        complex_surface_name = str('cplx_sur_nb_{}_by_ext_{}_and_{}_'.format(nb, \n",
    "                            first_face_to_extend.name, second_face_to_extend.name))\n",
    "        new_complex_surface = knowledge_framework().Complex_Surface( name = complex_surface_name)\n",
    "    \n",
    "    \n",
    "    coord_labels = physical_space.coordinate_labels\n",
    "    # get candidate stratigraphic_parts paramters\n",
    "    n1 = np.array(physical_space.get_object_coordinates( object= first_face_to_extend, kind= \"normal\")) \n",
    "    n2 = np.array(physical_space.get_object_coordinates( object= second_face_to_extend, kind= \"normal\")) \n",
    "    c1 = np.array(physical_space.get_object_coordinates( object= first_face_to_extend, kind= \"center\")) \n",
    "    c2 = np.array(physical_space.get_object_coordinates( object= second_face_to_extend, kind= \"center\")) \n",
    "\n",
    "    nodes1 = np.array(physical_space.get_object_coordinates( object= first_face_to_extend, kind= \"nodes\")) \n",
    "    nodes2 = np.array(physical_space.get_object_coordinates( object= second_face_to_extend, kind= \"nodes\")) \n",
    "\n",
    "    common_two_nodes = common_two_nodes_two_planars(nodes1, nodes2)\n",
    "    axis = np.array(common_two_nodes[0])-np.array(common_two_nodes[1])\n",
    "\n",
    "    proposed_node_of_extension = project_point_onto_plane(proposed_node_of_extension, nodes1) if force_projection_of_point_on_part1_plane == True else proposed_node_of_extension\n",
    "\n",
    "    center1_proj_on_axis = np.array(compute_point_projection_onto_line(c1, np.array(common_two_nodes[0]), axis))\n",
    "    forbidden_axis_for_part1 = center1_proj_on_axis-c1\n",
    "    forbidden_axis_for_part1/= np.linalg.norm(forbidden_axis_for_part1) \n",
    "    center2_proj_on_axis = np.array(compute_point_projection_onto_line(c2, np.array(common_two_nodes[0]), axis))\n",
    "    forbidden_axis_for_part2 = center2_proj_on_axis-c2\n",
    "    forbidden_axis_for_part2/= np.linalg.norm(forbidden_axis_for_part2)\n",
    "\n",
    "    extention_axis_part1 = np.array(proposed_node_of_extension) - np.array(node_to_fix) \n",
    "    extention_axis_part1/= np.linalg.norm(extention_axis_part1)\n",
    "    if force_axis is not None:\n",
    "        force_axis /= np.linalg.norm(force_axis)\n",
    "    \n",
    "    if all(extention_axis_part1 == forbidden_axis_for_part1) or all(force_axis == forbidden_axis_for_part1):\n",
    "        raise MalissiaBaseError('the proposed surface cannot be extend in the direction toward the intersection of the surfaces')\n",
    "    \n",
    "    new_nodes_part1_temp = compute_larger_surface_by_extension(*nodes1,node_to_fix, proposed_node_of_extension,\n",
    "                                        force_axis_direction = force_axis)     \n",
    "    n = 0 \n",
    "    n_part_cpmlx_sur = len(new_complex_surface.has_Part)+1\n",
    "    new_nodes_part1 = []\n",
    "    for n_i in new_nodes_part1_temp:\n",
    "        name= 'N{}_{}'.format(n, n_part_cpmlx_sur)\n",
    "        n +=1\n",
    "        n_part_cpmlx_sur +=1\n",
    "        n_i =  [float(i) for i in n_i]\n",
    "        new_nodes_part1.append(constructor_point(knowledge_framework, coord_labels, n_i, name))\n",
    "   \n",
    "    projection_proposed_node_of_extension_2 = project_point_onto_plane(proposed_node_of_extension, nodes2)\n",
    "\n",
    "    new_nodes_part2_temp = compute_larger_surface_by_extension(*nodes2, \n",
    "                                                               node_to_fix, \n",
    "                                                               projection_proposed_node_of_extension_2,\n",
    "                                        force_axis_direction = force_axis) \n",
    "    n = 0 \n",
    "    n_part_cpmlx_sur += 1\n",
    "    new_nodes_part2 = []\n",
    "    for n_ii in new_nodes_part2_temp:\n",
    "        name= 'N{}_{}'.format(n, n_part_cpmlx_sur)\n",
    "        n +=1\n",
    "        n_part_cpmlx_sur +=1\n",
    "        n_ii =  [float(ii) for ii in n_ii]\n",
    "        new_nodes_part2.append(constructor_point(knowledge_framework, coord_labels, n_ii, name))\n",
    "\n",
    "    common_nodes = common_two_nodes_two_planars(new_nodes_part1_temp, new_nodes_part2_temp)\n",
    "    share_sides_nb = len(knowledge_framework().Side.instances())+1\n",
    "    point_nb =  len(knowledge_framework().Point.instances())+1\n",
    "    end_point_0 = constructor_point(knowledge_framework, coord_labels,\n",
    "                        [float(x) for x in common_nodes[0]], name=\"end_point_nb_{}\".format(point_nb))\n",
    "    end_point_1 = constructor_point(knowledge_framework, coord_labels,\n",
    "                        [float(x) for x in common_nodes[0]], name=\"end_point_nb_{}\".format(point_nb+1))\n",
    "    share_sides_name = str('shared_side_nb_{}_between_{}_and_{}'.format(share_sides_nb, end_point_0.name, end_point_1.name))\n",
    "    side_size = float(np.linalg.norm(np.array(common_nodes[0])-np.array(common_nodes[1])))\n",
    "    shared_side = knowledge_framework().Side(name = share_sides_name, has_End_Points = [end_point_0, end_point_1], \n",
    "                                             size = [side_size])    \n",
    "    \n",
    "    \n",
    "    if force_construction_of_first_part == True:\n",
    "        two_parts = multiple_parts_constructor_for_complex_surface(knowledge_framework, new_complex_surface,\n",
    "                                                                 physical_space, [new_nodes_part1, new_nodes_part2])\n",
    "        \n",
    "        shared_side.name = str('shared_side_nb_{}_between_{}_and_{}'.format(share_sides_nb, two_parts[0].name, two_parts[1].name))\n",
    "        two_parts[0].has_Shared_Side.append(shared_side)\n",
    "        two_parts[1].has_Shared_Side.append(shared_side)\n",
    "        attribute_parts_nodes_to_complex_surface(new_complex_surface)\n",
    "        return new_complex_surface\n",
    "    if force_construction_of_first_part == False:\n",
    "\n",
    "        shared_side.name = str('shared_side_nb_{}_between_{}_and_{}'.format(share_sides_nb,\n",
    "                                                                             part2.name, first_face_to_extend.name))\n",
    "\n",
    "        part2 =    multiple_parts_constructor_for_complex_surface(knowledge_framework, new_complex_surface,\n",
    "                                                                 physical_space, [new_nodes_part2, ])[0]\n",
    "        first_face_to_extend.has_Shared_Side.append(shared_side)\n",
    "        part2.has_Shared_Side.append(shared_side)\n",
    "        attribute_parts_nodes_to_complex_surface(new_complex_surface)\n",
    "        return new_complex_surface\n",
    "\n",
    "def get_one_extreme_face(complex_surface):\n",
    "    \"\"\"Method to get one extreme face of a complex_surface that have a problem with geometry\n",
    "    \"\"\"\n",
    "    if len(complex_surface.has_Part) < 2 :\n",
    "        raise MalissiaBaseError('Wrong condition for one extreme face extraction : the complex_surface {} has {} part'.format(complex_surface.name,\n",
    "                                                                                                                             len(complex_surface.has_Part) ))\n",
    "    extreme_faces = [part_i for part_i in complex_surface.has_Part if (len(part_i.has_Neighbor) ==1 and part_i.has_Neighbor[0] in complex_surface.has_Part\n",
    "                                                                        and len(part_i.has_Unmatched_Neighbor) == 0)]\n",
    "    if len(extreme_faces) < 1 or len(extreme_faces) > 2 : \n",
    "        print('Warning, complex_surface {} has {} extreme faces, None is returned'.format(complex_surface.name, len(extreme_faces)))\n",
    "        return None\n",
    "    else:\n",
    "        return extreme_faces[0]\n",
    "                     \n",
    "def compute_larger_surface_by_extension_of_complex_surface(knowledge_framework,physical_space,\n",
    "                                                           candidate_complex_surface, \n",
    "                                                           proposed_node_of_extension, \n",
    "                                                           new_complex_surface = None, \n",
    "                                                           new_complex_surface_name = None,\n",
    "                                                           extend_only_laterally = True,\n",
    "                                                           force_projection = False, \n",
    "                                                            extend_one_extreme_face = False,\n",
    "                                                            forced_extreme_face = None,\n",
    "                                                            force_axis_direction_for_one_face_extention = None, \n",
    "                                                              use_face_as_new_first_part = False,\n",
    "                                                                forced_new_first_part = None, \n",
    "                                                                extreme_part_associated_with_forced_new_part = None\n",
    "                                                                ):\n",
    "    \n",
    "    \"\"\"Method to construct a new complex surface by the extension of an existing complex_surface with more than two sides.\n",
    "    - the candidate_complex_surface must be deformed.\n",
    "    - the method has the argument extend_only_laterally true by default as it is primarly to extend deformed surfaces laterally\n",
    "    - the proposed point of extension could be on one face of exntesion and respecting the condition of the extension of one planar surface\n",
    "       or anywhere on the space and it will be projected on the shared axis of the chosen face and its neighbor, for this second option,\n",
    "       the force_projection must be True and exten.\n",
    "    - the method could be used to extend only one surface by extension using a point anywhere i the space, for this extend_one_extreme_face must be True and extend_only_laterally False\n",
    "       and a forced face must be given in forced_extreme_face. If the point allow only extending in the opposite direction toward the shared axis of the extreme \n",
    "       face and its neighbor, an axis of forcing must be given in force_axis_direction_for_one_face_extention and that is orthogonal \n",
    "       on the shared axis.\n",
    "    - the method could be used to extend only laterally the candidate complex_surface and preserving a forced face that is extended elswhere.\n",
    "       For this option, use_face_as_new_first_part must be True, extend_only_laterally False, extreme_part_associated_with_forced_new_part and forced_new_first_part must be given.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    # add coodiantes labels if none in args \n",
    "    coord_labels = physical_space.coordinate_labels\n",
    "    # check if the complex surface have more than two parts\n",
    "    if len(candidate_complex_surface.has_Part) < 2:\n",
    "        raise MalissiaBaseError('the {} has less than two parts'.format(candidate_complex_surface))\n",
    "    \n",
    "    # create the new complex surface if it is not passed\n",
    "    if new_complex_surface is None:\n",
    "        if new_complex_surface_name is not None:\n",
    "            new_complex_surface = knowledge_framework().Complex_Surface(name = str(new_complex_surface_name), non_planar = True)\n",
    "        else:\n",
    "            nb_of_cplx_sur = len(knowledge_framework().Complex_Surface.instances())\n",
    "            new_complex_surface_name = str('cplx_sur_nb_{}'.format(nb_of_cplx_sur + 1))\n",
    "            new_complex_surface = knowledge_framework().Complex_Surface(name = new_complex_surface_name, non_planar = True)\n",
    "\n",
    "\n",
    "    # get candidate faces total extension of the complex surface but only laterally\n",
    "    if extend_only_laterally == True:\n",
    "        if force_projection != True:\n",
    "            # get the two extreme faces of the complex surface, for that the surface must be non_planar\n",
    "            #two_extreme_complex_surface_parts = compute_complex_surface_extreme_surfaces(knowledge_framework,\n",
    "            #                                                                            candidate_complex_surface) \n",
    "            # check if the proposed point is at least on the plane of one of the extreme faces\n",
    "            two_extreme_complex_surface_parts = [candidate_complex_surface.has_Part[0], candidate_complex_surface.has_Part[-1]] # small fix until resolving problem with extreme faces and nb of neighbors\n",
    "            extreme_face = None\n",
    "            for part in two_extreme_complex_surface_parts:\n",
    "                vertices = np.array(physical_space.get_object_coordinates( object= part, kind= \"nodes\")) \n",
    "                dist_from_plane = np.linalg.norm(np.array(project_point_onto_plane(proposed_node_of_extension, \n",
    "                                                                    vertices))-np.array(proposed_node_of_extension))\n",
    "                if np.linalg.norm(dist_from_plane) == 0:\n",
    "                    extreme_face = part\n",
    "                    break\n",
    "            if extreme_face == None:\n",
    "                raise MalissiaBaseError('the proposed node of extension {} is not on the same plane of any extreme face of the {}'.format(proposed_node_of_extension, candidate_complex_surface))\n",
    "\n",
    "        else:\n",
    "            extreme_face = get_one_extreme_face(candidate_complex_surface)\n",
    "            vertices = np.array(physical_space.get_object_coordinates( object= extreme_face, kind= \"nodes\"))\n",
    "            second_part = extreme_face.has_Neighbor[0]\n",
    "            nodes2 = physical_space.get_object_coordinates( object= second_part, kind= \"nodes\")\n",
    "            common_nodes = common_two_nodes_two_planars(vertices, nodes2)\n",
    "            node_to_fix = find_farthest_node_from_nodes(common_nodes, proposed_node_of_extension)\n",
    "            direction_of_forced_axis = common_nodes[0] if node_to_fix == common_nodes[1] else common_nodes[1]\n",
    "            force_axis = np.array(direction_of_forced_axis) - np.array(node_to_fix)\n",
    "            proposed_node_of_extension = compute_point_projection_onto_line(proposed_node_of_extension,\n",
    "                                                                            node_to_fix, force_axis)\n",
    "        \n",
    "        # define initial first and second parts that will be extended\n",
    "        first_part = extreme_face\n",
    "        second_part = first_part.has_Neighbor[0]\n",
    "        first_part.extended  = False\n",
    "\n",
    "    # get candidate faces for extension of one extreme face\n",
    "    elif extend_only_laterally != True and extend_one_extreme_face == True:\n",
    "        if forced_extreme_face is None:\n",
    "            raise MalissiaBaseError('an extreme face of the complex_surface must be given')\n",
    "        else:\n",
    "            extreme_face = forced_extreme_face\n",
    "            vertices = np.array(physical_space.get_object_coordinates( object= extreme_face, kind= \"nodes\"))\n",
    "            second_part = extreme_face.has_Neighbor[0]\n",
    "            nodes2 = physical_space.get_object_coordinates( object= second_part, kind= \"nodes\")\n",
    "            common_nodes = common_two_nodes_two_planars(vertices, nodes2)\n",
    "            node_to_fix = find_farthest_node_from_nodes(common_nodes, proposed_node_of_extension)\n",
    "            new_nodes_part1_temp = compute_larger_surface_by_extension(*vertices,\n",
    "                                         node_to_fix, proposed_node_of_extension,\n",
    "                                        force_axis_direction = force_axis_direction_for_one_face_extention)# to be tested\n",
    "            n = 0 \n",
    "            n_part_cpmlx_sur = len(new_complex_surface.has_Part)+1\n",
    "            new_nodes_part1 = []\n",
    "            for n_i in new_nodes_part1_temp:\n",
    "                name= 'N{}_{}'.format(n, n_part_cpmlx_sur)\n",
    "                n +=1\n",
    "                n_part_cpmlx_sur +=1\n",
    "                n_i =  [float(i) for i in n_i]\n",
    "                new_nodes_part1.append(constructor_point(knowledge_framework, coord_labels, n_i, name))\n",
    "\n",
    "            new_first_part = multiple_parts_constructor_for_complex_surface(knowledge_framework, new_complex_surface,\n",
    "                                                                 physical_space, [new_nodes_part1])[0]\n",
    "            if is_point_on_line_projection(proposed_node_of_extension, common_nodes[0], common_nodes[1]):\n",
    "                for part in candidate_complex_surface.has_Part:\n",
    "                    if part != extreme_face:\n",
    "                        new_complex_surface.has_Part.append(part) #to be checked\n",
    "                return new_complex_surface\n",
    "            else:\n",
    "                axis = np.array(common_nodes[0]) - np.array(common_nodes[1])\n",
    "                proposed_node_of_extension = compute_point_projection_onto_line(proposed_node_of_extension, \n",
    "                                                                              common_nodes[0], axis)\n",
    "                # define initial first and second parts that will be extended\n",
    "                first_part = new_first_part\n",
    "                second_part = first_part.has_Neighbor[0]\n",
    "                first_part.extended  = True\n",
    "                second_part.extended  = False\n",
    "                \n",
    "    # get candidate faces to extend a surface laterally and use an existing already extended first part\n",
    "    elif extend_only_laterally != True and use_face_as_new_first_part == True :\n",
    "        if forced_new_first_part is None or extreme_part_associated_with_forced_new_part is None:\n",
    "            raise MalissiaBaseError('the forced extended face and the old part from the candidate \\\n",
    "                                     surface must be given in forced_new_first_part = \"?\" \\\n",
    "                                    and extreme_part_associated_with_forced_new_part = \"?\"')\n",
    "        else:\n",
    "            new_complex_surface.has_Part.append(forced_new_first_part)\n",
    "            first_part = extreme_part_associated_with_forced_new_part\n",
    "            second_part = first_part.has_Neighbor[0]\n",
    "            first_part.extended  = True\n",
    "            second_part.extended  = False\n",
    "\n",
    "    \n",
    "    if extend_only_laterally != True and extend_one_extreme_face != True and use_face_as_new_first_part != True :\n",
    "        raise MalissiaBaseError('one option  extend_only_laterally or extend_one_extreme_face or  use_face_as_new_first_part must be chosen, or built new method ')\n",
    "\n",
    "    # apply extension on each part based on the previous identified faces to extend, \n",
    "    ## for that all parts must be successive neighbors (this should be ensured as if complex surface is not checked neighbors are not set)\n",
    "    for part_i in range(len(candidate_complex_surface.has_Part)):\n",
    "        if first_part.extended == True and second_part.extended == True :\n",
    "            break\n",
    "        else:\n",
    "            nodes1 = physical_space.get_object_coordinates( object= first_part, kind= \"nodes\")\n",
    "            nodes2 = physical_space.get_object_coordinates( object= second_part, kind= \"nodes\")\n",
    "            common_nodes = common_two_nodes_two_planars(nodes1, nodes2)\n",
    "            projection_point_of_extension_on_part1 = project_point_onto_plane(proposed_node_of_extension, nodes1)# add condition for first projection\n",
    "            node_to_fix = find_farthest_node_from_nodes(common_nodes, projection_point_of_extension_on_part1)\n",
    "            direction_of_forced_axis = common_nodes[0] if node_to_fix == common_nodes[1] else common_nodes[1]\n",
    "            force_axis = np.array(direction_of_forced_axis) - np.array(node_to_fix)\n",
    "            sign = not first_part.extended  \n",
    "            new_complex_surface = compute_larger_surface_by_extension_of_two_non_planars_complex_surface(knowledge_framework,\n",
    "                                    physical_space,first_part ,second_part,\n",
    "                                    node_to_fix, projection_point_of_extension_on_part1, \n",
    "                                    new_complex_surface, force_axis = force_axis,\n",
    "                                    force_projection_of_point_on_part1_plane = True, \n",
    "                                    force_construction_of_first_part = sign)\n",
    "            first_part.extended = True\n",
    "            second_part.extended = True\n",
    "            \n",
    "            if len(second_part.has_Neighbor) > 2:\n",
    "                raise MalissiaBaseError('the part {} has more than two neighbors, which is not accepted in this case'.format(first_part))\n",
    "            elif len(second_part.has_Neighbor) == 2:\n",
    "                first_part = second_part\n",
    "                second_part = first_part.has_Neighbor[0] if first_part.has_Neighbor[0].extended != True else first_part.has_Neighbor[1]\n",
    "            else:\n",
    "                first_part = second_part\n",
    "                second_part = first_part.has_Neighbor[0]\n",
    "\n",
    "    # reset extension parameters to false of the candidate and new complex surfaces parts for next applications\n",
    "    for part_i in new_complex_surface.has_Part:# adding checking of all surfaces have been extended than reset\n",
    "        part_i.extended = False\n",
    "    for part_i in candidate_complex_surface.has_Part:\n",
    "        part_i.extended = False\n",
    "    attribute_parts_nodes_to_complex_surface(new_complex_surface)\n",
    "    return new_complex_surface\n",
    "    \n",
    " \n",
    "\n",
    "\n",
    "def attribute_parts_nodes_to_complex_surface(complex_surface):\n",
    "    nestded_nodes = []\n",
    "    for part in complex_surface.has_Part:\n",
    "        nestded_nodes.extend(part.has_Representation)\n",
    "    complex_surface.has_Representation = nestded_nodes\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Check complex surface"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# complex surface checking and evaluation\n",
    "\n",
    "def check_surface_parallelism(normal1, normal2,  tolerance = 3):\n",
    "    \"\"\"Method to check if two surfaces are parallel or not. It returns True or False.\n",
    "    Parameter:\n",
    "    - normal1:  the normal of the first surface\n",
    "    - normal2:  the normal of the second surface\n",
    "    - tolerance : degree of tolerance\"\"\"    \n",
    "    dot_prod = np.dot(normal1,normal2) / (np.linalg.norm(normal1) * np.linalg.norm(normal2))\n",
    "    if  not -1<= dot_prod <= 1:\n",
    "        dot_prod = np.round(dot_prod,0)\n",
    "    angle_deg = np.rad2deg(np.arccos(dot_prod))\n",
    "    if    0 +tolerance >= angle_deg >= 0-tolerance or  180+tolerance >= angle_deg >= 180-tolerance:\n",
    "        return True\n",
    "    else:\n",
    "        return False    \n",
    "\n",
    "def check_same_polarity_of_parallel_surfaces(normal1, normal2):\n",
    "    \"\"\"Method to check if two surfaces have the same polarity when their normals are parallel. It returns True or False.\n",
    "    Parameter:\n",
    "    - normal1:  the normal of the first surface\n",
    "    - normal2:  the normal of the second surface\n",
    "    \"\"\"  \n",
    "    if np.dot(normal1, normal2) > 0:\n",
    "        return True\n",
    "    else: \n",
    "        return False\n",
    "    \n",
    "def check_if_two_surfaces_coplanar(point_on_surface1,  point_on_surface2, normal, tolerance = 3 ):\n",
    "    \"\"\"Method to check if two parallel surfaces are on the same plane. It returns True or False.\n",
    "    Parameter:\n",
    "    - point_on_surface1:  a point on the first surface ex: center or node\n",
    "    - point_on_surface2:  a point on the second surface ex: center or node\n",
    "    - normal:  a normal of one surface\n",
    "    - tolerance : degree of tolerance\"\"\"  \n",
    "    vec = np.array((point_on_surface1))- np.array((point_on_surface2))\n",
    "    # first check \n",
    "    if  all([x ==0  for x in vec]):\n",
    "        return False\n",
    "    if 90 +tolerance >= (np.rad2deg(np.arccos(np.dot(normal, vec)))) >= 90-tolerance:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "def check_point_inside_surface(point, surface_nodes, normal_vector):\n",
    "    \"\"\"Method to check if a point is insied a surface. It returns True or False.\n",
    "    The point must be on the same plane as the surface\n",
    "    Parameter:\n",
    "    - point:  the point to be checked\n",
    "    - surface_nodes:  four nodes of the surface\n",
    "    - normal_vector : normal vector of the surface\"\"\"  \n",
    "    # Check if the point is on the same side of all edges\n",
    "    for i in range(4):\n",
    "        next_node = surface_nodes[(i + 1) % 4]\n",
    "        edge_vector = next_node - surface_nodes[i]\n",
    "        point_to_node = point - surface_nodes[i]\n",
    "        cross_product = np.cross(edge_vector, point_to_node)\n",
    "\n",
    "        if np.dot(cross_product, normal_vector) < 0:\n",
    "            return False  # The point is on the opposite side of this edge\n",
    "    return True  # The point is inside the polygon\n",
    "\n",
    "def check_two_coplanar_surface_inclusion(candidate_larger_surface_nodes,  candidate_smaller_surface_nodes,\n",
    "                                         candidate_larger_surface_normal ):\n",
    "    \"\"\"Method to check if two parallel surfaces are totally overlapping. It returns True or False.\n",
    "    Parameter:\n",
    "    - candidate_larger_surface_nodes:  nodes of the surface possibally including a smaller surface\n",
    "    - candidate_smaller_surface_nodes:  nodes of the surface possibally included in a larger surface\n",
    "    - normal:  the normal of candidate_larger_surface_nodes\n",
    "    \"\"\"  \n",
    "    if all([check_point_inside_surface(node_i, \n",
    "                                               candidate_larger_surface_nodes, \n",
    "                                               candidate_larger_surface_normal) for node_i in \n",
    "                                               candidate_smaller_surface_nodes]):\n",
    "        return True\n",
    "    else:\n",
    "        return False  \n",
    "\n",
    " \n",
    "\n",
    "def are_vectors_parallel(v, w):\n",
    "    \"\"\"Method to check if vectors are parllel. It returns True or False.\n",
    "    Parameter:\n",
    "    - v:  first vector \n",
    "    - w:  second vector\n",
    "    \"\"\"  \n",
    "\n",
    "    # Check if vectors are parallel\n",
    "    if np.allclose(np.cross(v, w), np.zeros_like(v)):\n",
    "            return True  # Vectors are parallel and in the same direction\n",
    "    return False\n",
    "\n",
    "\n",
    "def check_complex_surface_neighbor_number_and_arrangement(complex_surface, knowledge_framework, physical_space ):\n",
    "    \"\"\"\n",
    "    Method to check if the number and arrangement of neighbors in a complex_surface by calculating actual numer of neighbors and the expected number.\n",
    "        It returns a boolean value. \n",
    "\n",
    "    Parameter:\n",
    "    - complex_surface : the complex_surface\n",
    "    - physical_space : the physical_space\n",
    "    - knowledge_framework : the knowledge_framework \n",
    "    \"\"\" \n",
    "    \n",
    "    parts = complex_surface.has_Part\n",
    "    neighbor_constructor_from_multiple_planars(complex_surface, knowledge_framework, physical_space)\n",
    "    # add if more then two has one neighbor ==> false\n",
    "    nb_parts = len(parts)\n",
    "    if nb_parts < 2 :\n",
    "        raise MalissiaBaseError('the complex_surface _must have at least two parts')\n",
    "    if nb_parts == 2:\n",
    "        if parts[0] in parts[1].has_Neighbor or parts[1] in parts[0].has_Neighbor:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "    expected_total_of_neighbors = (nb_parts-1)*2\n",
    "    actual_total_of_neighbors = 0\n",
    "    # actual_total_of_neighbors = sum(neigh in complex_surface.has_Part for part in parts for neigh in part.has_Neighbor)\n",
    "    for part in parts:\n",
    "        for neigh in part.has_Neighbor:\n",
    "            if neigh in complex_surface.has_Part:\n",
    "                actual_total_of_neighbors +=1\n",
    "    #print(nb_parts, expected_total_of_neighbors, actual_total_of_neighbors)\n",
    "    return expected_total_of_neighbors == actual_total_of_neighbors\n",
    "    \n",
    "\n",
    "\n",
    "def shared_sides_are_parallel(complex_surface, knowledge_framework, physical_space, tolerance = 0.1):\n",
    "\n",
    "    \"\"\"\n",
    "    Method to check if shared sides are parallel. It returns True or False. \n",
    "\n",
    "    Parameter:\n",
    "    - complex_surface : the complex_surface\n",
    "    - physical_space : the physical_space\n",
    "    - knowledge_framework : the knowledge_framework \n",
    "    \"\"\" \n",
    "\n",
    "    list_of_shared_sides_in_complex_surf= get_shared_sides_in_one_complex_surface(complex_surface, knowledge_framework, physical_space)\n",
    "    unmatched_side = get_unmatched_shared_sides_in_one_complex_surface(complex_surface, knowledge_framework, physical_space)\n",
    "    sides = list_of_shared_sides_in_complex_surf + unmatched_side\n",
    "    reference_side = sides[0]\n",
    "    start_point, end_point = reference_side.has_End_Points[0], reference_side.has_End_Points[1]\n",
    "    coor_start = physical_space.get_object_coordinates( object= start_point, kind= \"node\")[0]\n",
    "    coor_end = physical_space.get_object_coordinates( object= end_point, kind= \"node\")[0]\n",
    "    reference_side_vec = np.array(coor_end) - np.array(coor_start)\n",
    "    reference_side_vec /= np.linalg.norm(reference_side_vec)\n",
    "    print('sides', sides)\n",
    "    for side in sides:\n",
    "        start_point, end_point = side.has_End_Points[0], side.has_End_Points[1]\n",
    "        coor_start = physical_space.get_object_coordinates( object= start_point, kind= \"node\")[0]\n",
    "        coor_end = physical_space.get_object_coordinates( object= end_point, kind= \"node\")[0]\n",
    "        side_i_vec = np.array(coor_end) - np.array(coor_start) \n",
    "        side_i_vec /= np.linalg.norm(side_i_vec)\n",
    "        if not np.linalg.norm(np.cross(reference_side_vec,side_i_vec )) <= 0 +tolerance  :\n",
    "            print(side, reference_side)\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "def shared_sides_are_equal(complex_surface, knowledge_framework, physical_space):\n",
    "    \"\"\"\n",
    "    Method to check if shared sides are equal. It returns True or False. \n",
    "\n",
    "    Parameter:\n",
    "    - complex_surface : the complex_surface\n",
    "    - physical_space : the physical_space\n",
    "    - knowledge_framework : the knowledge_framework \n",
    "    \"\"\" \n",
    "    if not shared_sides_are_parallel(complex_surface  = complex_surface, knowledge_framework  = knowledge_framework, \n",
    "                                                                                   physical_space =  physical_space):\n",
    "        raise MalissiaBaseError('to test if the shared sides are equal they must be parallel, which seems not to be the case')\n",
    "    list_of_shared_sides_in_complex_surf= get_shared_sides_in_one_complex_surface(complex_surface  = complex_surface,\n",
    "                                                                                   knowledge_framework  = knowledge_framework, \n",
    "                                                                                   physical_space =  physical_space)\n",
    "    unmatched_side = get_unmatched_shared_sides_in_one_complex_surface(complex_surface  = complex_surface,\n",
    "                                                                                   knowledge_framework  = knowledge_framework, \n",
    "                                                                                   physical_space =  physical_space)\n",
    "    sides = list_of_shared_sides_in_complex_surf + unmatched_side\n",
    "    initial_size = sides[0].size[0]\n",
    "    # check if all size are not equal \n",
    "    if not all([np.round(np.abs(initial_size - side.size[0]),1) == 0. for side in sides ]):\n",
    "        return False\n",
    "    else:\n",
    "        return True\n",
    "\n",
    "def shared_sides_have_uniform_allignement(complex_surface, knowledge_framework, physical_space):\n",
    "    \"\"\"\n",
    "    Method to check if shared sides have uniform allignement. It returns True or False. \n",
    "\n",
    "    Parameter:\n",
    "    - complex_surface : the complex_surface\n",
    "    - physical_space : the physical_space\n",
    "    - knowledge_framework : the knowledge_framework \n",
    "    \"\"\" \n",
    "    if not shared_sides_are_equal(complex_surface, knowledge_framework, physical_space):\n",
    "        raise MalissiaBaseError('to test if the shared have uniform allignement, they must be equal, which seems not to be the case')\n",
    "    list_of_shared_sides_in_complex_surf= get_shared_sides_in_one_complex_surface(complex_surface  = complex_surface,\n",
    "                                                                                   knowledge_framework  = knowledge_framework, \n",
    "                                                                                   physical_space =  physical_space)\n",
    "    unmatched_side = get_unmatched_shared_sides_in_one_complex_surface(complex_surface  = complex_surface,\n",
    "                                                                                   knowledge_framework  = knowledge_framework, \n",
    "                                                                                   physical_space =  physical_space)\n",
    "    sides = list_of_shared_sides_in_complex_surf + unmatched_side\n",
    "    reference_side = sides[0]\n",
    "    start_point, end_point = reference_side.has_End_Points[0], reference_side.has_End_Points[1]\n",
    "    ref_coor_start = physical_space.get_object_coordinates( object= start_point, kind= \"node\")[0]\n",
    "    ref_coor_end = physical_space.get_object_coordinates( object= end_point, kind= \"node\")[0]\n",
    "    reference_side_vec = np.array(ref_coor_end) - np.array(ref_coor_start)\n",
    "    for side in sides :\n",
    "        start_point, end_point = side.has_End_Points[0], reference_side.has_End_Points[1]\n",
    "        coor_start = physical_space.get_object_coordinates( object= start_point, kind= \"node\")[0]\n",
    "        coor_end = physical_space.get_object_coordinates( object= end_point, kind= \"node\")[0]\n",
    "        projected_end = compute_point_projection_onto_line(coor_end, ref_coor_end, reference_side_vec )\n",
    "        projected_start = compute_point_projection_onto_line(coor_start, ref_coor_end, reference_side_vec )\n",
    "        condition_1 =  is_point_on_line_projection(projected_end, ref_coor_end, ref_coor_start)\n",
    "        condition_2 =  is_point_on_line_projection(projected_start, ref_coor_end, ref_coor_start)\n",
    "        if not condition_1 or not condition_2:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "\n",
    "\n",
    "def are_vectors_perpendicular(v1, v2):\n",
    "    dot_product = np.dot(v1, v2)\n",
    "    return np.isclose(dot_product, 0)\n",
    "    \n",
    "def check_chirality_projection(part1, part2, knowledge_framework, physical_space, \n",
    "                              same_complex_surface_condition= False):\n",
    "    \"\"\"Method to check the chirality of two representation of stratigraphic parts. Parts should be neighbors.\n",
    "    The method computes the normals and orientations directly if surfaces are parllel, or the projection of the \n",
    "    surfaces on a common plane if the normals are not parallel. Based on the comparaison of the projected normals the poalirty is defined.\n",
    "    \n",
    "    Parameters:\n",
    "    - part1 : planar surface representation of the first part\n",
    "    - part2 : planar surface representation of the second part\n",
    "    - physical_space : the physical_space\n",
    "    - knowledge_framework : the knowledge_framewrok\n",
    "    - same_complex_surface_condition : boolean by default False to allow forcing the condition of belononging to the \n",
    "                                        same complex_surface for part1 and part2\n",
    "    \"\"\"\n",
    "\n",
    "    neighbor_constructor_from_two_planars(part1, part2, knowledge_framework = knowledge_framework, \n",
    "                                          physical_space =physical_space, \n",
    "                                          same_complex_surface_condition= same_complex_surface_condition)\n",
    "    n1 = physical_space.get_object_coordinates(part1, \"normal\")\n",
    "    n2 = physical_space.get_object_coordinates(part2, \"normal\")\n",
    "    n1 = np.array(n1)\n",
    "    n2 = np.array(n2)\n",
    "\n",
    "    if are_vectors_parallel(n1, n2):\n",
    "        return are_parallel_and_same_direction(n1, n2)\n",
    "\n",
    "    c1 = physical_space.get_object_coordinates(part1, \"center\")\n",
    "    c2 = physical_space.get_object_coordinates(part2, \"center\")\n",
    "    c1 = np.array(c1)\n",
    "    c2 = np.array(c2)\n",
    "    nodes1 = physical_space.get_object_coordinates(part1, \"nodes\")\n",
    "    nodes1 = np.array(nodes1)\n",
    "    nodes2 = physical_space.get_object_coordinates(part2, \"nodes\")\n",
    "    nodes2 = np.array(nodes2)\n",
    "\n",
    "    if are_vectors_perpendicular(n1, n2):\n",
    "        extreme_nodes = compute_extremeties_from_two_extreme_surfaces([part1, part2],physical_space)\n",
    "        extremeties_part1 = np.array([np.array(n_i) for n_i in extreme_nodes[0]])\n",
    "        extremeties_part2 =  np.array([np.array(n_i) for n_i in extreme_nodes[1]])\n",
    "\n",
    "        farthest_p2node_from_n0_p1 = find_farthest_node_from_nodes(extremeties_part2, extremeties_part1[0])\n",
    "        closest_p2node_from_n0_p1 = extremeties_part2[0] if set(farthest_p2node_from_n0_p1) == set(extremeties_part2[1]) \\\n",
    "                                    else extremeties_part2[1]\n",
    "        new_surface_of_projection_nodes = np.array([\n",
    "                                                farthest_p2node_from_n0_p1,\n",
    "                                                closest_p2node_from_n0_p1,\n",
    "                                                extremeties_part1[0],\n",
    "                                                extremeties_part1[1] \n",
    "                                                                        ])\n",
    "        projection_of_p1_nodes_on_new_surf = [project_point_onto_plane(node_i, \n",
    "                                            new_surface_of_projection_nodes) for node_i in nodes1]\n",
    "        project_p1_normal = compute_normal_vector(projection_of_p1_nodes_on_new_surf)\n",
    "        projection_of_p2_nodes_on_new_surf = [project_point_onto_plane(node_i, \n",
    "                                            new_surface_of_projection_nodes) for node_i in nodes2]\n",
    "        project_p2_normal = compute_normal_vector(projection_of_p2_nodes_on_new_surf)\n",
    "        return are_parallel_and_same_direction(project_p1_normal, project_p2_normal)\n",
    "    else:\n",
    "        projected_p1_on_p2 = [project_point_onto_plane(node_i, \n",
    "                                            nodes2) for node_i in nodes1]\n",
    "        project_p1_on_p2_normal = compute_normal_vector(projected_p1_on_p2)\n",
    "        if not are_vectors_parallel(n2, project_p1_on_p2_normal):\n",
    "            raise MalissiaBaseError('problem with projection of {} on {}'.format(part1.name, part2,name))\n",
    "        return  are_parallel_and_same_direction(n2, project_p1_on_p2_normal)\n",
    "\n",
    "def check_chirality_vectors(part1, part2, knowledge_framework, physical_space):\n",
    "    n1 = physical_space.get_object_coordinates(part1, \"normal\")\n",
    "    n2 = physical_space.get_object_coordinates(part2, \"normal\")\n",
    "    n1 = np.array(n1)\n",
    "    n2 = np.array(n2)\n",
    "\n",
    "    if are_vectors_parallel(n1, n2):\n",
    "        return are_parallel_and_same_direction(n1, n2)\n",
    "\n",
    "    c1 = physical_space.get_object_coordinates(part1, \"center\")\n",
    "    c2 = physical_space.get_object_coordinates(part2, \"center\")\n",
    "    c1 = np.array(c1)\n",
    "    c2 = np.array(c2)\n",
    "    nodes1 = physical_space.get_object_coordinates(part1, \"nodes\")\n",
    "    nodes1 = np.array(nodes1)\n",
    "    nodes2 = physical_space.get_object_coordinates(part2, \"nodes\")\n",
    "    nodes2 = np.array(nodes2)\n",
    "    axis = compute_fold_axis(n1, c1, n2, c2)\n",
    "    inter_point = compute_intersection_point(c1, n1, c2, n2,axis  )\n",
    "    v1 = c1-inter_point\n",
    "    v2 = c2-inter_point\n",
    "    cross_v1_n1 = np.cross(v1, n1)\n",
    "    cross_v2_n2 = np.cross(v2, n2)\n",
    "    return not are_parallel_and_same_direction(cross_v1_n1, cross_v2_n2)\n",
    " \n",
    "    \n",
    "\n",
    "#discontinuous_stratigraphy_anomaly_constructor\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Representation Spaces"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We distinguish two kind of operations here:\n",
    "* representation\n",
    "* visualisation\n",
    "\n",
    "A representation is a formal description of how something appears in a given representation space, but it doesn't have to be visualised.<br>\n",
    "A visualisation takes care of the rendering of a representation with a given support (image, screen)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Representation should also be made a bit more abstract.<br>\n",
    "1. There is a variety of object that can be rendered in a representation space (typically, different kinds of a dataset components)\n",
    "2. Several kinds of representation spaces could be envisionned (e.g., spatial 1D,2D,3D, or temporal, or just an abstract text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import gc\n",
    "import numpy as np\n",
    "import pyvista as pv\n",
    "from scipy import linalg\n",
    "\n",
    "class RepresentationSpace(object):\n",
    "    \"\"\"A general framework for Representating geological objects\"\"\"\n",
    "    \n",
    "    def __init__(self, knowledge_framework = None):\n",
    "        \"\"\"Initialise base class attributes\"\"\"\n",
    "        self.knowledge_framework = knowledge_framework if knowledge_framework is not None else GeologicalKnowledgeManager().get_knowledge_framework()\n",
    "        self._datasets= []\n",
    "        self._interpreted_objects = []\n",
    "        \n",
    "    def attach_dataset(self, dataset, use_extension= True, padding= None):\n",
    "        \"\"\"Attach a dataset to the representation space\n",
    "        \n",
    "        Parameters:\n",
    "        - dataset: a Dataset object to be attached\n",
    "        - use_extension: if True, uses the extension of the dataset, else keeps the current ones\n",
    "        - padding: if use_extension is True, the given paddign will be used to keep a space around the dataset\"\"\"\n",
    "        if dataset == None: return\n",
    "        if dataset in self._datasets: return\n",
    "        self._datasets += [dataset]\n",
    "        \n",
    "        if use_extension:\n",
    "            self.set_extension_from_data(padding= padding)\n",
    "        \n",
    "        dataset.setup_representation_space(physical_space= self)\n",
    "    \n",
    "    def get_datasets(self):\n",
    "        \"\"\"dataset getter\"\"\"\n",
    "        return self._datasets\n",
    "        \n",
    "    def attach_interpreted_object(self, interpreted_object, update_extension= True, padding= None):\n",
    "        \"\"\"Attach an interpreted object to the representation space\n",
    "        \n",
    "        Parameters:\n",
    "        - interpreted_object: an interpreted object  to be attached\n",
    "        - update_extension: if True, uses the extension of the interpreted object, else keeps the current ones\n",
    "        - padding: if use_extension is True, the given padding will be used to keep a space around the interpreted object\"\"\"\n",
    "        if interpreted_object == None: return\n",
    "        if interpreted_object in self._interpreted_objects: return\n",
    "        self._interpreted_objects += [interpreted_object]\n",
    "        \n",
    "        if update_extension:\n",
    "            self.update_extension_from_interpreted_object([interpreted_object], padding=padding)\n",
    "            \n",
    "    def get_interpreted_objects(self):\n",
    "        \"\"\"interpreted objects getter\"\"\"\n",
    "        return self._interpreted_objects\n",
    "        \n",
    "class TemporalRepresentationSpace(RepresentationSpace):\n",
    "    \"\"\"A `RepresentationSpace` representing temporal apsects of represented objects.\"\"\"\n",
    "    \n",
    "class PhysicalRepresentationSpace(RepresentationSpace):\n",
    "    \"\"\"A type of `RepresentationSpace` representing physical aspects of the represented objects.\"\"\"\n",
    "    \n",
    "    __default_coordinate_labels = [\"X\",\"Y\",\"Z\"]\n",
    "    \n",
    "    def __init__(self, dimension: int=None, coordinate_labels: str|list= None, dataset= None, **kargs):\n",
    "        \"\"\"Initialisation of the representation space.\n",
    "        \n",
    "        Parameters:\n",
    "        - dimension (int): specify the number of dimensions of the representation space, typically 1D, 2D, or 3D (i.e., 1, 2, or 3),\n",
    "        NB: larger dimension spaces are not supported. At least either the `dimension` parameter or `coordinate_label` parameter should be given.\n",
    "        - coordinate_labels(str|list(str)): gives the label(s) of the coordinates. If given, the number of dimensions is deduced from the size of the list\n",
    "        and `dimensions`is ignored, otherwise, the labels are taken from the `__default_coordinate_labels` based on the number of `dimension`s. \n",
    "        At least either the `dimension` parameter or `coordinate_label` parameter should be given.\n",
    "        - dataset: a Dataset object containing the data to be attached to this representation space.\n",
    "        Note that the RepresentationSpace can be created first and then updated automatically when creating the dataset attached to this space.\n",
    "        - **kargs:\n",
    "            - use_extension: if True, uses the extension of the dataset, else keeps the current ones\n",
    "            - padding: if use_extension is True, the given paddign will be used to keep a space around the dataset\n",
    "        \"\"\"       \n",
    "        super().__init__() \n",
    "        \n",
    "        assert not (coordinate_labels is None and dimension is None), \"At least one of the parameters should be specified\"\n",
    "        if coordinate_labels is None:\n",
    "            assert isinstance(dimension, int),\"dimension parameter must be an integer\"\n",
    "            assert dimension in [1,2,3], \"The specified number of dimensions ({:d}) is not supported, should be 1, 2 or 3.\".format(dimension)\n",
    "            self.dimension= dimension\n",
    "            self.coordinate_labels= PhysicalRepresentationSpace.__default_coordinate_labels[:self.dimension]\n",
    "        elif isinstance(coordinate_labels,str):\n",
    "            self.dimension= 1\n",
    "            self.coordinate_labels=  [coordinate_labels]\n",
    "        elif isinstance(coordinate_labels, list):\n",
    "            self.dimension= len(coordinate_labels)\n",
    "            self.coordinate_labels= coordinate_labels\n",
    "        else:\n",
    "            raise(\"Unsupported initialisation of representation space: dimension({}) and coordinate_label ({}).\\n At least one of the parameters shoudl be specified.\".format(dimension, coordinate_labels))\n",
    "\n",
    "        self.__default_padding= 0.2\n",
    "        self.set_extension(init=True)\n",
    "        self.attach_dataset(dataset,**kargs)\n",
    "        self.set_name()\n",
    "\n",
    "    def set_name(self):\n",
    "        \"\"\"\n",
    "        Set the 'name' attribute to the given value.\n",
    "        Parameters:\n",
    "        - self\n",
    "        \"\"\"\n",
    "        if not hasattr(self, '_name'):\n",
    "            gc.collect()\n",
    "            # Get a list of all objects tracked by the garbage collector\n",
    "            all_objects = gc.get_objects()\n",
    "            count_of_instances = len([obj for obj in all_objects if isinstance(obj, PhysicalRepresentationSpace)])\n",
    "            name = str('PhysicalRepresentationSpace_nb_{}'.format(count_of_instances+1))\n",
    "            self._name = name\n",
    "\n",
    "    def get_name(self):\n",
    "        \"\"\"\n",
    "        Get the current value of the 'name' attribute.\n",
    "\n",
    "        Returns:\n",
    "        - str: The current value of the 'name' attribute.\n",
    "        \"\"\"\n",
    "        return self._name\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    def get_extension(self):\n",
    "        \"\"\"returns the extensions of the space\"\"\"\n",
    "        return self.extension\n",
    "    \n",
    "    def get_size(self):\n",
    "        \"\"\"returns the size of the space in each dimension\"\"\"\n",
    "        ext = np.array(self.extension)\n",
    "        return ext[:,1] - ext[:,0]\n",
    "    \n",
    "    def get_center(self):\n",
    "        \"\"\"returns the center of the space\"\"\"\n",
    "        return np.mean(self.extension, axis= 1)\n",
    "    \n",
    "    def generate_random_location(self, n= 1):\n",
    "        \"\"\"Generates n random location uniformly distributed within the space extensions\"\"\"\n",
    "        return np.random.default_rng().uniform(low= self.extensions[:0], high= self.extensions[:1], size= n)\n",
    "    \n",
    "    def generate_random_dip(self, n= 1):\n",
    "        \"\"\"Generates n random dip values that are compatible with this space\"\"\"\n",
    "        return np.random.default_rng().uniform(0, 90, n)\n",
    "\n",
    "    def generate_random_dip_dir(self, n= 1):\n",
    "        \"\"\"Generates n random dip_dir values that are compatible with this space\n",
    "        \n",
    "        Note: The values are hardcoded to be in XZ cross section to simplify the example\"\"\"\n",
    "        return np.random.default_rng().choice([90,270], n)#np.random.default_rng().uniform(0, 360, n)\n",
    "    \n",
    "    def generate_random_polarity(self, n= 1):\n",
    "        \"\"\"Generates n random polarity values (-1 or 1)\"\"\"\n",
    "        return np.random.default_rng().choice([-1,1], n)\n",
    "    \n",
    "    def generate_random_size(self, n=1, min_perc= 0.05, max_perc= 0.99):\n",
    "        \"\"\"Generates n random size values\"\"\"\n",
    "        sizes = self.get_size()\n",
    "        max_sizes = max(sizes)\n",
    "        return np.random.default_rng().uniform(min_perc*max_sizes, max_perc*max_sizes, n)\n",
    "        \n",
    "    def set_extension(self, extension:list= None, padding:float= None, init:bool= False):\n",
    "        \"\"\"Setter for the extension (min,max) of the representation space\n",
    "        \n",
    "        Parameters:\n",
    "        - extension: a list containing a pair of min and max value for each dimension of the space.\n",
    "        If None, the default will be set, i.e., [[0,1]] * dimension\n",
    "        - padding: a space that is left around the dataset, either a value compatible with the coordinates, or a list of values of same dimensions.\n",
    "        If None, by default the padding is 5% of the dataset range.\n",
    "        - init: (default False) if True the extension will be set to the given one, or default if extension is None;\n",
    "        if False, the extension will be updated with the given one\n",
    "        \"\"\"\n",
    "        if extension is None:\n",
    "            if init or (self.extension is None):\n",
    "                self.extension = np.array([[0,1]] * self.dimension)\n",
    "                self.actual_extension = None\n",
    "                self.initialised_extension = False\n",
    "            return\n",
    "        extension= np.array(extension)\n",
    "        assert extension.shape[0] == self.dimension, \"The specified extension ({}) do not match the space dimensions ({})\".format(extension, self.dimension)\n",
    "        assert extension.shape[1] == 2, \"The specified extension should provide both lower andupper bounds for each dimension, given: {}\".format(extension)\n",
    "        \n",
    "        # if reset is False then update extension\n",
    "        if (init is False) and (self.initialised_extension is True):    \n",
    "            for dim_i in range(self.dimension):\n",
    "                extension[dim_i,0] = min(extension[dim_i,0], self.actual_extension[dim_i,0])\n",
    "                extension[dim_i,1] = max(extension[dim_i,1], self.actual_extension[dim_i,1])\n",
    "        \n",
    "        # padding\n",
    "        if padding is None:\n",
    "            padding= self.__default_padding\n",
    "        else:\n",
    "            try: # check if padding as a dimension\n",
    "                len(padding)\n",
    "            # if not, then use it a a scaling \n",
    "            except TypeError: #just checking it is a number\n",
    "                assert type(padding) == int or type(padding) == float, \"padding should be given as a number (int or float), here: \"+type(padding)\n",
    "                # keep the padding as is in this case\n",
    "            else:# else check its dimensions are ok\n",
    "                assert len(padding) == self.dimension, \"the dimensions of the specified padding (len({})->) should match the space dimension ({})\".format(padding, len(padding), self.dimension)\n",
    "                padding= np.array(padding)\n",
    "                \n",
    "        self.center= np.mean(extension, axis= 1)\n",
    "        diff= extension.T - self.center\n",
    "        diff= diff.T\n",
    "        \n",
    "        # padding is multiplied by the width along each axis and added to the extension\n",
    "        # check if each dimension is shrinked (ie. min == max -> diff == 0), takes the average extension of the other dimensions,\n",
    "        # unless all are shrinked, in which case [[-1,1]] * self.dimension is set\n",
    "        if np.all(diff == 0):\n",
    "            diff = np.array([[-1,1]] * self.dimension)\n",
    "        else:\n",
    "            zero_diff = np.where(~diff.any(axis=1))\n",
    "            non_zero_diff = np.where(diff.any(axis=1))\n",
    "            mean_diff = np.mean(diff[non_zero_diff], axis=0)\n",
    "            diff[zero_diff] = mean_diff\n",
    "        \n",
    "        self.actual_extension = extension \n",
    "        self.extension= np.repeat([self.center],2,axis=0).T + (1+2*padding)*diff\n",
    "        self.initialised_extension = True\n",
    "        \n",
    "    def set_extension_from_data(self, padding= None, init= False):\n",
    "        \"\"\"Sets the extension of the space from the attached dataset\n",
    "        \n",
    "        If no dataset is attached yet, then default extension are used instead (min:0,max:1).\n",
    "        \n",
    "        Parameters:\n",
    "        - padding: a space that is left around the dataset, either a value compatible with the coordinates, or a list of values of same dimensions.\n",
    "        If None, by default the padding is 5% of the dataset range.\n",
    "        \"\"\"\n",
    "        non_empty_dataset = [data_i for data_i in self._datasets if data_i.extension is not None]\n",
    "        if len(non_empty_dataset) == 0:\n",
    "            self.set_extension(init= init)\n",
    "            return\n",
    "                \n",
    "        extension = np.array(non_empty_dataset[0].extension)\n",
    "        for data_i in non_empty_dataset[1:]:\n",
    "            for dim_i in range(self.dimension):\n",
    "                extension[dim_i,0] = min(extension[dim_i,0], data_i.extension[dim_i])\n",
    "                extension[dim_i,1] = max(extension[dim_i,1], data_i.extension[dim_i])\n",
    "        \"\"\":todo: use projected coordinates instead of source coordinates, might fail if 3D data projected on a map\"\"\"\n",
    "        \n",
    "        self.set_extension(extension, padding=padding, init= init)\n",
    "        \n",
    "    def update_extension_from_interpreted_object(self, objects= None, padding= None, init= False):\n",
    "        \"\"\"Sets the extension of the space from the attached objects\n",
    "        \n",
    "        Parameters:\n",
    "        - padding: a space that is left around the dataset, either a value compatible with the coordinates, or a list of values of same dimensions.\n",
    "        If None, by default the padding is 5% of the dataset range.\n",
    "        \"\"\"\n",
    "        objects = self._interpreted_objects if objects is None else objects\n",
    "        objects = [objects] if not isinstance(objects, list) else objects\n",
    "            \n",
    "        if len(objects) == 0:\n",
    "            self.set_extension(init= init)\n",
    "            return\n",
    "                \n",
    "        first_obj = objects[0]\n",
    "        coord = self.get_object_coordinates(first_obj, kind= \"nodes\")\n",
    "        extension = np.array([np.min(coord, axis=0),np.max(coord, axis=0)]).T\n",
    "        for obj_i in objects[1:]:\n",
    "            for dim_i in range(self.dimension):\n",
    "                obj_i_coord = self.get_object_coordinates(obj_i, kind= \"nodes\")\n",
    "                extension_i = np.array([np.min(obj_i_coord, axis=0),np.max(obj_i_coord, axis=0)]).T\n",
    "                extension[dim_i,0] = min(extension[dim_i,0], extension_i[dim_i,0])\n",
    "                extension[dim_i,1] = max(extension[dim_i,1], extension_i[dim_i,1])\n",
    "        \"\"\":todo: use projected coordinates instead of source coordinates, might fail if 3D data projected on a map\"\"\"\n",
    "        \n",
    "        self.set_extension(extension, padding=padding, init= init)\n",
    "        \n",
    "    def filter_qualities(self,**qualities):\n",
    "        \"\"\"removes the named arguments corresponding to this space coordinates from qualities.\n",
    "        \n",
    "        Return:\n",
    "        - a copy with the passed parameters except for the ones correpsonding to the space coordinates\"\"\"\n",
    "        qualities =  {key:val for key, val in qualities.items() if key not in self.coordinate_labels}\n",
    "        return qualities\n",
    "    \n",
    "    def prepare_coordinate_qualities(self, **qualities):\n",
    "        \"\"\"transforms the coordinates passed in qualities into an appropriate format\n",
    "        \n",
    "        Return:\n",
    "        - a dict with quality keys and values for setting coordinates\"\"\"\n",
    "        coordinates = {key:val for key, val in qualities.items() if key in self.coordinate_labels}\n",
    "        coord_qualities = {}\n",
    "        for i,key in enumerate(self.coordinate_labels):\n",
    "            if key in coordinates:\n",
    "                val = coordinates[key]\n",
    "                coord_qualities[\"coord{}\".format(i+1)] = val if isinstance(val,list) else [val]\n",
    "                coord_qualities[\"coord{}_label\".format(i+1)] = [key]\n",
    "        return coord_qualities\n",
    "    \n",
    "    def label_map(self, object):\n",
    "        \"\"\"creates of mapping of coordinate labels\"\"\"\n",
    "        coord_label_params = [\"coord{}_label\".format(i) for i in range(1,4) if hasattr(object, \"coord{}_label\".format(i))]\n",
    "        non_empty_coord_label_param = [param for param in coord_label_params if len(getattr(object,param)) > 0]\n",
    "        label_map = {getattr(object,param)[0]:param for param in non_empty_coord_label_param if getattr(object,param)[0] in self.coordinate_labels}\n",
    "        return label_map\n",
    "        \n",
    "    def set_object_coordinates(self, object, **kargs):\n",
    "        \"\"\"Sets the coordinates corresponding to this space into the given object\n",
    "        \n",
    "        Parameters:\n",
    "        - object: the object whose coordinates needs to be set\n",
    "        - kargs: keyword argugments corresponding to the name and values of the coordinates.\n",
    "        They must match this space coordinate names, extra names will be ignored\"\"\"\n",
    "        \n",
    "        # find the object representation and check it is a point\n",
    "        #otherwise another setter must be used\n",
    "        if (object.has_Representation is None) or (len(object.has_Representation) < 1):\n",
    "            raise MalissiaBaseError(\"can't set the object coordinates because it doesn't have a geometrical representation\")\n",
    "        rep = object.has_Representation[0]\n",
    "        if not self.knowledge_framework.isinstance(rep, self.knowledge_framework().Point):\n",
    "            raise MalissiaBaseError(\"can't set the object coordinates because its geometrical representation is not a Point\")            \n",
    "        \n",
    "        # check if the object has coord{i}_label set, else set it\n",
    "        if mogi.has_qualities(rep, [\"coord{}_label\".format(i) for i in range(1,len(self.coordinate_labels)+1)]):\n",
    "            label_map = self.label_map(rep)\n",
    "            coordinate_values = {label_map[key].split(\"_\")[0]:(kargs[key] if isinstance([kargs[key]],list) else [kargs[key]])\n",
    "                                  for key in self.coordinate_labels if key in kargs}\n",
    "        else:\n",
    "            coordinate_values = self.prepare_coordinate_qualities(**kargs)\n",
    "        for param_name, val in coordinate_values.items():\n",
    "            setattr(rep, param_name, val)\n",
    "          \n",
    "    def _get_coord(self, object):\n",
    "        label_map = self.label_map(object)\n",
    "        coord = np.full_like(self.coordinate_labels, np.nan, dtype= float)\n",
    "        for i, key in enumerate(self.coordinate_labels):\n",
    "            if key in label_map:\n",
    "                coord_param = label_map[key].split(\"_\")[0]\n",
    "                coord[i] = getattr(object,coord_param)[0]\n",
    "        return coord \n",
    "    \n",
    "    def _get_coord_from_list(self, object_list):\n",
    "        coord = np.full((len(object_list),len(self.coordinate_labels)), np.nan, dtype= float)\n",
    "        for i, rep_i in enumerate(object_list):\n",
    "            label_map = self.label_map(rep_i)\n",
    "            for j, key in enumerate(self.coordinate_labels):\n",
    "                if key in label_map:\n",
    "                    coord_param = label_map[key].split(\"_\")[0]\n",
    "                    coord[i,j] = getattr(rep_i,coord_param)[0]\n",
    "        return coord\n",
    "    \n",
    "    def get_object_coordinates(self, object, kind= \"center\"):\n",
    "        \"\"\"Gets the coordinates corresponding to this space from the given object\"\"\"\n",
    "        \n",
    "        if object is None:\n",
    "            raise MalissiaBaseError(\"can't get the object coordinates because it is None\")\n",
    "            \n",
    "        # if the object is a Representation_Concept use it directly else check if it has a representation\n",
    "        if self.knowledge_framework.isinstance(object, self.knowledge_framework().Representation_Concept):\n",
    "            rep = object\n",
    "            n_rep = 1\n",
    "        else:\n",
    "            rep = object.has_Representation\n",
    "            n_rep = 0 if rep is None else len(rep)\n",
    "            if (rep is None) or (n_rep == 0):\n",
    "                raise MalissiaBaseError(\"can't get the object coordinates because it doesn't have a geometrical representation\")\n",
    "            if n_rep == 1:\n",
    "                rep = rep[0]\n",
    "                \n",
    "        if kind == \"center\":\n",
    "            if n_rep == 1:\n",
    "                if (rep.has_Center is None) or (len(rep.has_Center) == 0):\n",
    "                    raise MalissiaBaseError(\"can't get the object center because its center is not defined\")\n",
    "                center = rep.has_Center[0]\n",
    "            else:\n",
    "                centers = [rep_i.has_Center[0] for rep_i in rep if (rep_i.has_Center is not None) and (len(rep_i.has_Center)>0)]\n",
    "                if len(centers) >1:\n",
    "                    print(\"Warning: found more than one center, using center[0]\")\n",
    "                if (len(centers) == 0):\n",
    "                    raise MalissiaBaseError(\"can't get the object center because its center is not defined\")\n",
    "                center = centers[0]\n",
    "            if not self.knowledge_framework.isinstance(center, self.knowledge_framework().Point):\n",
    "                raise MalissiaBaseError(\"can't get the object center because its center is not a Point\") \n",
    "        \n",
    "            return self._get_coord(center)\n",
    "        \n",
    "        if kind == \"vect\":\n",
    "            if n_rep == 1:\n",
    "                vector = rep\n",
    "                if not self.knowledge_framework.isinstance(vector, self.knowledge_framework().Vector):\n",
    "                    raise MalissiaBaseError(\"can't get the object vector coordinate because is not a Vector\") \n",
    "            else:\n",
    "                vectors = [rep_i.has_Center[0] for rep_i in rep if (rep_i.has_Center is not None) and (len(rep_i.has_Center)>0)]\n",
    "                if len(vectors) >1:\n",
    "                    print(\"Warning: found more than one vector-> using vector[0]\")\n",
    "                vector = vectors[0]\n",
    "        \n",
    "            return self._get_coord(vector)\n",
    "        \n",
    "        elif (kind == \"node\") or (kind == \"nodes\"):\n",
    "            if n_rep == 1:\n",
    "                # check it has at least one node or center\n",
    "                if not (\n",
    "                        ((rep.has_Node1 is not None) and (len(rep.has_Node1) > 0)) \n",
    "                        or\n",
    "                        ((rep.has_Center is not None) and (len(rep.has_Center) > 0)) \n",
    "                    ):\n",
    "                    raise MalissiaBaseError(\"can't get the object node coordinates because it has no Nodes nor Center\")\n",
    "                # if so the nodes should be listed in the rep\n",
    "                nodes = rep.has_Representation\n",
    "            else:\n",
    "                nodes = [rep_i.has_Representation for rep_i in rep if (rep_i.has_Node1 is not None) and (len(rep_i.has_Node1)>0) and (rep_i.has_Representation is not None)]\n",
    "\n",
    "            if (nodes is None) or (len(nodes) == 0):\n",
    "                raise MalissiaBaseError(\"can't get the object nodes because its representation is not defined\")\n",
    "            nodes = [node_i for node_i in nodes if self.knowledge_framework.isinstance(node_i, self.knowledge_framework().Point)]\n",
    "            if len(nodes) == 0:\n",
    "                raise MalissiaBaseError(\"can't get the object coordinates because its geometrical representation are not a Point\") \n",
    "            \n",
    "            return self._get_coord_from_list(nodes)\n",
    "        \n",
    "        if kind == \"normal\":\n",
    "            \n",
    "            if n_rep == 1:\n",
    "                if (rep.has_Normal is None) or (len(rep.has_Normal) == 0):\n",
    "                    raise MalissiaBaseError(\"can't get the object normal because its normal is not defined\")\n",
    "                normal = rep.has_Normal[0]\n",
    "            else:\n",
    "                normals = [rep_i.has_Normal[0] for rep_i in rep if (rep_i.has_Normal is not None) and (len(rep_i.has_Normal)>0)]\n",
    "                if len(normals) >1:\n",
    "                    print(\"Warning: found more than one normal, using normal[0]\")\n",
    "                if (len(normals) == 0):\n",
    "                    raise MalissiaBaseError(\"can't get the object normal because its normal is not defined\")\n",
    "                normal = normals[0]\n",
    "            if not self.knowledge_framework.isinstance(normal, self.knowledge_framework().Vector):\n",
    "                raise MalissiaBaseError(\"can't get the object normal because its normal is not a Vector\") \n",
    "        \n",
    "            return self._get_coord(normal)\n",
    "        \n",
    "        if kind == \"size\":\n",
    "            \n",
    "            if n_rep == 1:\n",
    "                if (rep.size is None) or (len(rep.size) == 0):\n",
    "                    raise MalissiaBaseError(\"can't get the object size because its size is not defined\")\n",
    "                size = rep.size[0]\n",
    "            else:\n",
    "                sizes = [rep_i.size[0] for rep_i in rep if (rep_i.size is not None) and (len(rep_i.size)>0)]\n",
    "                if len(sizes) >1:\n",
    "                    print(\"Warning: found more than one size, using sizes[0]\")\n",
    "                if (len(sizes) == 0):\n",
    "                    raise MalissiaBaseError(\"can't get the object size because its size is not defined\")\n",
    "                size = sizes[0]\n",
    "            return float(size)\n",
    "        \n",
    "        else:\n",
    "            raise MalissiaBaseError(\"Type of coordinates not available:\"+kind)\n",
    "    \n",
    "    def coordinates_to_dict(self, coords):\n",
    "        \"\"\" transforms a coordinate array into an appropriate dict with labels\"\"\"\n",
    "        return {label:value for label,value in zip(self.coordinate_labels, coords)}\n",
    "    \n",
    "    def get_normal_vector(self, feature):\n",
    "        dip = feature.dip\n",
    "        dip_dir = feature.dip_dir\n",
    "        return self.compute_normal_from_dip_dir(dip, dip_dir)\n",
    "        \n",
    "    def compute_normal_from_dip_dir(self, dip, dip_dir, polarity= 1):\n",
    "        dip_rad = np.deg2rad(dip)\n",
    "        dip_dir_rad = np.deg2rad(dip_dir)\n",
    "        z = np.cos(dip_rad)\n",
    "        h = np.sin(dip_rad)\n",
    "        y = h * np.cos(dip_dir_rad)\n",
    "        x = h * np.sin(dip_dir_rad)\n",
    "        return polarity * np.array([x,y,z])\n",
    "    \n",
    "    def compute_dip_dir_from_normal(self, normal):\n",
    "        polarity = 1 if normal[2] == 0 else np.sign(normal[2]) \n",
    "        x,y,z = polarity * np.array(normal) / np.linalg.norm(normal)\n",
    "        if np.abs(z) == 1:\n",
    "            return 0,0,z\n",
    "        dip = np.rad2deg(np.arccos(z))\n",
    "        dip_dir = np.rad2deg(np.arctan2(x,y)) % 360\n",
    "        return dip, dip_dir, polarity\n",
    "    \n",
    "    def compute_line_attitude_from_two_points(self, p0, p1, center= False, reduce_dimension= None):\n",
    "        \"\"\"Computes the attitude of a line going through two points\n",
    "        \n",
    "        Parameters:\n",
    "        - p0: coordinates of the first point\n",
    "        - p1: coordinates of the second point\n",
    "        - reduce_dimension: optional, default None, if set, the given coordinate is set to 0 to simulate projection on a cross section\n",
    "        \n",
    "        Returns:\n",
    "        - attitude: a dictionnary holding\n",
    "          \"dip_dir\" : the dip direction of the line. +or- 1 if dimension is  <3, value otherwise\n",
    "          \"dip\" : the dip of the line (ie., downward). None if dimension is <2, value otherwise\n",
    "        \"\"\"\n",
    "        v = np.array(p1) - np.array(p0)\n",
    "        center = np.mean([p1,p0],axis=0) if center else np.zeros(v.shape[-1])\n",
    "        if reduce_dimension is not None:\n",
    "            v[reduce_dimension] = 0\n",
    "            center[reduce_dimension] = np.mean([p0[reduce_dimension],p1[reduce_dimension]])\n",
    "        if len(v) == 1:\n",
    "            dip_dir = np.sign(v)[0]\n",
    "            dip = None\n",
    "        else:\n",
    "            # make v downward\n",
    "            if v[-1] > 0:\n",
    "                v *= -1 \n",
    "            if len(v) == 2:\n",
    "                dip_dir = np.sign(v[0])\n",
    "                v_abs = np.abs(v)\n",
    "                dip = np.rad2deg(np.arctan2(v_abs[1], v_abs[0]))\n",
    "            else:\n",
    "                dip_dir = np.rad2deg(np.arctan2(v[0],v[1]))\n",
    "                dip_dir = 360 - np.abs(dip_dir) if dip_dir < 0 else dip_dir\n",
    "                dip = -np.rad2deg(np.arctan2(v[2], np.linalg.norm(v[:2]) ))\n",
    "        size = np.linalg.norm(v)\n",
    "                \n",
    "        return {\"dip_dir\":dip_dir, \"dip\":dip, \"center\":center, \"size\":size}\n",
    "            \n",
    "    def compute_principal_directions(self, p, center= False, ):\n",
    "        \"\"\"Computes the principal directions in a set of vectors\n",
    "        \n",
    "        This can be used to compute the principal vectors in a set of vectors\n",
    "        or medium plan in a group of points (needs to set center to True).\n",
    "        \n",
    "        Parameters:\n",
    "        - p: points/vectors in the shape (# points, # dimensions)\n",
    "        - center: tells if points should be centered first, important for computing medium plane, default is False\n",
    "        \n",
    "        Returns: a dictionnary with:\n",
    "        - \"values\": the singular values of the principal axes\n",
    "        - \"vectors\": the vectors of the principal axes\n",
    "        - \"center\": the center of points if center is set to True, zeros otherwise\n",
    "        \"\"\"\n",
    "        p = np.array(p)\n",
    "        center = np.mean(p,axis=0) if center else np.zeros(p.shape[-1])\n",
    "        p = p - center\n",
    "        mat = np.dot(p.T, p)\n",
    "        _,s,Vh = linalg.svd(mat)\n",
    "        result = {\n",
    "            \"values\": s,\n",
    "            \"vectors\": Vh,\n",
    "            \"center\": center\n",
    "        }\n",
    "        return result\n",
    "    \n",
    "    def compute_average_vector(self, vectors):\n",
    "        \"\"\"Compute the average vector\"\"\"\n",
    "        principal_directions = self.compute_principal_directions(vectors)\n",
    "        principal_vectors = principal_directions[\"vectors\"]\n",
    "        return principal_vectors[0]\n",
    "    \n",
    "    def compute_attitude_from_points(self, p):\n",
    "        \"\"\"Computes the attitude dip and dip_dir for a medium plane going through points\n",
    "        \n",
    "        Parameters:\n",
    "        - p: the points coordinates given in shape ()\n",
    "        \"\"\"\n",
    "        if len(p) < self.dimension:\n",
    "            raise MalissiaBaseError(\"Underdetermined attitude computation.\")\n",
    "            \n",
    "        if self.dimension == 2:\n",
    "            return self.compute_line_attitude_from_two_points(p, center= True)\n",
    "        elif self.dimension == 3:\n",
    "            return self.compute_plane_from_points(p)\n",
    "        else:\n",
    "            raise MalissiaBaseError(\"unsupported dimension for attitude computation.\")\n",
    "        \n",
    "    def compute_plane_from_points(self, p):\n",
    "        \"\"\"Computes the attitude dip and dip_dir for a medium plane going through points\n",
    "        \n",
    "        Parameters:\n",
    "        - p: the points coordinates given in shape ()\n",
    "        \n",
    "        Returns:\n",
    "        - \"dip_dir\": azimuth from North towards the East, None if dip is zero\n",
    "        \"\"\"\n",
    "        principal_direction = self.compute_principal_directions(p, center= True)\n",
    "        \n",
    "        result = {}\n",
    "        result[\"center\"] = principal_direction[\"center\"]\n",
    "        result[\"major_axis\"] = principal_direction[\"vectors\"][0]\n",
    "        result[\"minor_axis\"] = principal_direction[\"vectors\"][1]\n",
    "        result[\"size\"] = np.sqrt(principal_direction[\"values\"][0])\n",
    "        \n",
    "        result[\"normal\"] = principal_direction[\"vectors\"][-1]\n",
    "        n = -result[\"normal\"] if result[\"normal\"][2]<0 else result[\"normal\"]\n",
    "        h = np.linalg.norm(n[:2])\n",
    "        result[\"dip\"] = np.rad2deg(np.arctan2(h, n[2]))\n",
    "        if h == 0:\n",
    "            result[\"dip_dir\"] = None\n",
    "        else:\n",
    "            dip_dir = np.rad2deg(np.arctan2(n[0], n[1])) % 360\n",
    "            result[\"dip_dir\"] = 360 - np.abs(dip_dir) if dip_dir < 0 else dip_dir\n",
    "        result[\"azimuth\"] = result[\"dip_dir\"] - 90 if result[\"dip_dir\"] > 90 else result[\"dip_dir\"] + 270\n",
    "        return result\n",
    "    \n",
    "    def compute_projection_on_plane(self, plane, object):\n",
    "        center_part = self.get_object_coordinates(plane, kind= \"center\")\n",
    "        center_explained = self.get_object_coordinates(object, kind= \"center\") \n",
    "        vec = center_part - center_explained \n",
    "        \n",
    "        normal = self.get_object_coordinates(plane, kind= \"normal\")\n",
    "        return center_explained + np.dot(vec,normal) * normal\n",
    "    \n",
    "    def evaluate_coverage(self, objects= None):\n",
    "        \"\"\"Compute the proportion of the space that is covered by the given objects.\"\"\"\n",
    "        # Note this is done along the first coordinate only for now as we are working on cross sections\n",
    "        \n",
    "        # this is looking for the segments of space that are not covered yet\n",
    "        # initialise by considering the whole space as uncovered\n",
    "        ref_segment = np.array(self.actual_extension[0])\n",
    "        uncovered_segments = np.array(self._get_uncovered_space(reference_segment= ref_segment, objects=objects))\n",
    "        segment_length = uncovered_segments[:,1] - uncovered_segments[:,0]\n",
    "        return 1.0 - np.sum(segment_length) / (ref_segment[1] - ref_segment[0])\n",
    "        \n",
    "    def _get_uncovered_space(self, reference_segment, objects= None):\n",
    "        uncovered_segment = [np.copy(reference_segment)]\n",
    "        for obj_i in self._interpreted_objects if objects is None else objects:\n",
    "            self._remove_object_part(uncovered_segment, obj_i)\n",
    "        return uncovered_segment\n",
    "    \n",
    "    def _remove_object_part(self, segments, object):\n",
    "        coord_x = self.get_object_coordinates(object, kind=\"nodes\")[:,0]\n",
    "        obj_segment = np.array([min(coord_x), max(coord_x)])\n",
    "        return self._remove_segment_part(segments, obj_segment)\n",
    "    \n",
    "    def _remove_segment_part(self, segments, remove_part):\n",
    "        p0, p1 = remove_part\n",
    "        for seg in segments:\n",
    "            s0, s1 = seg\n",
    "            p0_inside= False\n",
    "            if (p0 > s0) and (p0 < s1):# first node is inside -> move seg to the remaining left part\n",
    "                seg[1] = p0 \n",
    "                p0_inside= True\n",
    "            if (p1 < s1) and (p1 > s0):# second node is inside -> \n",
    "                # create a second segment for the remaining right part if first was inside else move seg to the right\n",
    "                if p0_inside:\n",
    "                    segments += [[p1,s1]]\n",
    "                else:\n",
    "                    seg[0] = p1 \n",
    "        return segments\n",
    "\n",
    "    def __str__(self):\n",
    "        \"\"\"Description of the physical space parameters and data\n",
    "        \"\"\"\n",
    "        desc= [\"Representation space of type: {:s}\".format(type(self).__name__)]\n",
    "        desc+= [\"- Number of dimension(s): {}\".format(self.dimension)]\n",
    "        desc+= [\"- Coordinate label(s): {}\".format(self.coordinate_labels)]\n",
    "        desc+= [\"- Space extension:\"]\n",
    "        for dim_i, lim_i in zip(self.coordinate_labels,self.extension):\n",
    "            desc+= [\" |- Coord {}: {}\".format(dim_i, lim_i)]  \n",
    "        return \"\\n\".join(desc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "\n",
    "class GeologicalDataset(object):\n",
    "    \"\"\"A GeologicalDataset gathers information about geological data to be interpreted.\n",
    "    \n",
    "    This class is a hybrid ontology&python class. It is providing pythonic algorithm and high level interface,\n",
    "    while the data is actually stored in an ontology.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, physical_space= None, time_space= None, representation_spaces= None, knowledge_framework= None):\n",
    "        \"\"\"Initialises a `GeologicalDataset`\n",
    "        \n",
    "        Parameters:\n",
    "        - physical_space: a `PhysicalRepresentationSpace`,  which defines the spatial coordinates of this dataset\n",
    "        - time_space: a `TemporalRepresentationSpace`,  which defines the time coordinates of this dataset\n",
    "        - representation_spaces: list of `Representationspace`s to which the dataset must be attached\n",
    "        Note: datasets can be created without representation space and attached later on by using `RepresentationSpace.attach_dataset`\n",
    "        or `GeologicalDataset.setup_representation_space`.\n",
    "        Alternativelly, a single `PhysicalRepresentationspace` and or `TemporalRepresentationspace` can be given here if `physical_space` and `time_space` are None.\n",
    "        - default_representation_space: the main RepresentationSpace to which this dataset is attached.\n",
    "        If None and representation_spaces are provided, then the first one will be taken.\n",
    "        If the default one is not initially in the full list, then it is added to it.\n",
    "        - ontology: the name of the ontology to be used for storing the data.\n",
    "        If None, the default will be taken from `the GeologicalKnowledgeManager`.\n",
    "        \n",
    "        Internals: this method initialises several internal attributes:\n",
    "        - extension: represents the extension of the dataset in the attached representation space\n",
    "        (i.e., the default on if this dataset is represented in several representation spaces\n",
    "        - representation_spaces: the dataset can be attached to and represented into several representation spaces,\n",
    "        `physical_space` and `time_space` are included into this list.\n",
    "        \"\"\"\n",
    "        \n",
    "        self.knowledge_framework= knowledge_framework if knowledge_framework is not None else GeologicalKnowledgeManager().get_knowledge_framework()\n",
    "        \n",
    "        self.extension = None\n",
    "        \n",
    "        # setup representation spaces\n",
    "        self.representation_spaces= set()\n",
    "        if physical_space is None:\n",
    "            # try to initialise the physical space with first existing data\n",
    "            observations = self.get_observations()\n",
    "            if len(observations) > 0:\n",
    "                coord_labels = [getattr(observations[0],\"coord{}_label\".format(i)) for i in range(1,4)]\n",
    "                coord_labels = [label[0] for label in coord_labels if len(label)>0]\n",
    "                physical_space = PhysicalRepresentationSpace(coordinate_labels=coord_labels)\n",
    "        self.setup_representation_space(physical_space, time_space, representation_spaces)\n",
    "        \n",
    "        # register the datast in the listed representation spaces\n",
    "        for space_i in self.representation_spaces:\n",
    "            space_i.attach_dataset(self)\n",
    "        \n",
    "        # initialize extension of the dataset\n",
    "        self.update_extension()\n",
    "            \n",
    "    def __dell__(self):\n",
    "        self.remove_all_observations()\n",
    "\n",
    "    def __setup_space(self, space, space_type):\n",
    "        \"\"\"Check if space of given type is in list or parameter and return the appropriate value.\n",
    "        \n",
    "        Take the given physical/time space, or if None use the first one in the list, and if none just leave None.\n",
    "        Adds the space to the `self.representation_spaces` set.\"\"\"\n",
    "        if space is not None: \n",
    "            self.representation_spaces.add(space)\n",
    "            return space\n",
    "        if len(self.representation_spaces) == 0: return None\n",
    "        space_list= [space_i for space_i in self.representation_spaces if isinstance(space_i, space_type)]\n",
    "        return space_list[0] if len(space_list) > 0 else None\n",
    "    \n",
    "    def update_extension(self, update_representation_spaces= True):\n",
    "        \"\"\"Sets the extension of the dataset in the physical space from existing observations\n",
    "        \n",
    "        If there is no observation, `self.extension` is set to None\"\"\"\n",
    "        observations = self.get_observations()\n",
    "        if (len(observations) == 0) or (self.physical_space is None) or (self.physical_space.dimension == 0):\n",
    "            self.extension = None \n",
    "            return\n",
    "            \n",
    "        di = observations[0]\n",
    "        coord = self.physical_space.get_object_coordinates(di)\n",
    "        self.extension = np.repeat([coord],2,axis=0).T\n",
    "        for di in observations[1:]:\n",
    "            coord = self.physical_space.get_object_coordinates(di)\n",
    "            for j, val in enumerate(coord):\n",
    "                self.extension[j,0] = min(self.extension[j,0], val)\n",
    "                self.extension[j,1] = max(self.extension[j,1], val)\n",
    "                \n",
    "        if update_representation_spaces:\n",
    "            if self.physical_space is not None:\n",
    "                self.physical_space.set_extension_from_data()\n",
    "        \n",
    "    def setup_representation_space(self, physical_space= None, time_space= None, representation_spaces= None):\n",
    "        \"\"\"Setup the representation space list and default\n",
    "        \n",
    "        Parameters:\n",
    "        - physical_space: a `PhysicalRepresentationSpace`,  which defines the spatial coordinates of this dataset\n",
    "        - time_space: a `TemporalRepresentationSpace`,  which defines the time coordinates of this dataset\n",
    "        - representation_spaces: list of `Representationspace`s to which the dataset must be attached\n",
    "        Note: datasets can be created without representation space and attached later on by using `RepresentationSpace.attach_dataset`\n",
    "        or `GeologicalDataset.setup_representation_space`.\n",
    "        Alternativelly, a single `PhysicalRepresentationspace` and or `TemporalRepresentationspace` can be given here if `physical_space` and `time_space` are None.\n",
    "        \"\"\"\n",
    "        if representation_spaces is not None: self.representation_spaces = self.representation_spaces.union(representation_spaces)\n",
    "        self.physical_space = self.__setup_space(physical_space, PhysicalRepresentationSpace)\n",
    "        self.time_space = self.__setup_space(time_space, TemporalRepresentationSpace)\n",
    "        \n",
    "        for space in self.representation_spaces:\n",
    "            space.attach_dataset(self)\n",
    "        \n",
    "    def get_observations(self, observation_type= None, qualities= None, name= None):\n",
    "        \"\"\"Accessor to the observations stored in the internal ontology\n",
    "        \n",
    "        Parameters:\n",
    "        - observation_type: the type of the searched observations as defined by the internal ontology\n",
    "        - qualities: qualities to filter the observations (c.f. `KnowledgeFramework.search`)\n",
    "        - name: name of the serached observation (c.f. `KnowledgeFramework.search`)\"\"\"\n",
    "        observation_type = observation_type if observation_type is not None else self.knowledge_framework().PointBased_Observation\n",
    "        return self.knowledge_framework.search(type= observation_type, qualities= qualities, name= name)\n",
    "    \n",
    "    def get_unexplained_observations(self, observation_type= None, qualities= None, name= None):\n",
    "        \"\"\"Accessor filtering out explained observation\n",
    "        \n",
    "        Parameters:\n",
    "        - observation_type: the type of the searched observations as defined by the internal ontology\n",
    "        - qualities: qualities to filter the observations (c.f. `KnowledgeFramework.search`)\n",
    "        - name: name of the serached observation (c.f. `KnowledgeFramework.search`)\"\"\"\n",
    "        observations = self.get_observations(observation_type= observation_type, qualities= qualities, name= name)\n",
    "        observations = [obs_i for obs_i in observations if len(obs_i.is_Explained_By) == 0]\n",
    "        return observations\n",
    "    \n",
    "    def get_occurrence_observations(self):\n",
    "        \"\"\"helper method to access occurrence data, i.e., those having a occurrence quality\n",
    "        \n",
    "        :todo: for now the occurrence quality doesn't exist so all the observations are occurrence by default\"\"\"\n",
    "        return self.get_observations(qualities= \"occurrence\")\n",
    "    \n",
    "    def get_orientation_observations(self):\n",
    "        return self.get_observations(qualities= \"dip\")\n",
    "    \n",
    "    def remove_observation(self, observations, update_extension= True):\n",
    "        \"\"\"Removes the given observations stored in this dataset and internal ontology\n",
    "        \n",
    "        Parameters:\n",
    "        - observations: an iterable containing objects of the internal ontology.\n",
    "        Note that you can use the `search`method to get such a list\n",
    "        - update_extension: if True (default) the extension will be updated\"\"\"\n",
    "        self.knowledge_framework.remove_all_instances(observations)\n",
    "        if update_extension: self.update_extension()\n",
    "            \n",
    "    def remove_observation_by_name(self, name:str, update_extension= True):\n",
    "        \"\"\"Removes the given observations stored in this dataset and internal ontology\n",
    "        \n",
    "        Parameters:\n",
    "        - name: the name of the observation to be removed\n",
    "        - update_extension: if True (default) the extension will be updated\"\"\"\n",
    "        self.remove_observation(self.get_observations(name= name), update_extension)\n",
    "        \n",
    "    def remove_all_observations(self, update_extension= True):\n",
    "        \"\"\"Removes all the observations stored in this dataset and internal ontology\n",
    "        \n",
    "        Parameters:\n",
    "        - update_extension: if True (default) the extension will be updated.\n",
    "        Note: the update is performed only once at the end.\"\"\"\n",
    "        self.remove_observation(self.get_observations(), update_extension= False)\n",
    "        if update_extension: self.update_extension()\n",
    "        \n",
    "    def add_observation(self, name: str= None, update_extension= True, **kargs):\n",
    "        \"\"\"creates a new observation and adds it to te internal ontology\n",
    "        \n",
    "        Parameters:\n",
    "        - name: the name of the observation (similar to an observation id)\n",
    "        - update_extension: if True (default) the extension will be updated.\n",
    "        - **kargs:\n",
    "          |- any argument whose name corresponds to the `physical_space`coordinate labels or other properties.\n",
    "          |   Note: all the coordinates must be specified\n",
    "          |   Also Note: the arguments with None value are removed from the dict\"\"\"\n",
    "        if self.physical_space is  None:\n",
    "            raise MalissiaBaseError(\"Trying to add observation while physical space is not set. Please setup_representation_space first\")\n",
    "        \n",
    "        constructor = self.knowledge_framework.select_object_constructor(\"Observation\", dataset=self, **kargs)\n",
    "        new_observation = constructor(knowledge_framework= self.knowledge_framework, dataset= self, name= name, **kargs)\n",
    "        if update_extension: self.update_extension()\n",
    "        \n",
    "    def add_occurrence_observation(self, name: str, observed_object:str, occurrence= True, update_extension= True, **kargs):\n",
    "        \"\"\"creates a new occurrence observation and adds it to te internal ontology\n",
    "        \n",
    "        Parameters:\n",
    "        - name: the name of the observation (similar to an observation id)\n",
    "        - observed_object: the name of the observed object\n",
    "        - occurrence: True (default) if the object was observed here, False if it was observed that it is not there.\n",
    "        Note that this is different from not having observed that it is here, in which case there should not be an observation.\n",
    "        - update_extension: if True (default) the extension will be updated.\n",
    "        - **kargs:\n",
    "          |- any argument whose name corresponds to the `physical_space`coordinate labels or other properties.\n",
    "          |   Note: all the coordinates must be specified\"\"\"\n",
    "        if observed_object is not None: kargs[\"geology\"]= observed_object\n",
    "        if occurrence is not None: kargs[\"occurrence\"]= occurrence\n",
    "        self.add_observation(name, update_extension= update_extension, **kargs)\n",
    "    \n",
    "    def add_orientation_observation(self, name: str, observed_object:str, dip, dip_dir, occurrence= True, update_extension= True, **kargs):\n",
    "        \"\"\"creates a new orientation observation and adds it to te internal ontology\n",
    "        \n",
    "        Parameters:\n",
    "        - name: the name of the observation (similar to an observation id)\n",
    "        - observed_object: the name of the observed object\n",
    "        - dip: the value of the measured dip (in degrees, 0-90)\n",
    "        - dip_dir: the value of the dip direction (in degrees, 0-360, from North towards the East)\n",
    "        - occurrence: True (default) if the object was observed here.\n",
    "        This is the default behaviour because if the measurement was made here, we assume that the object actually existed\n",
    "        so this is in itself a proof ox occurrence. However, one might want to record the orientation without specifically attaching any\n",
    "        observation of occurrence, in which case None should be given for occurrence and the quality won't be set.\n",
    "        False, would not make much sense as it would imply that the orientation was measured but we observed that the object wasn't there.\n",
    "        - update_extension: if True (default) the extension will be updated.\n",
    "        - **kargs:\n",
    "          |- any argument whose name corresponds to the `physical_space`coordinate labels or other properties.\n",
    "          |   Note: all the coordinates must be specified\"\"\"\n",
    "        if occurrence is not None: kargs[\"occurrence\"]= occurrence\n",
    "        if occurrence == False: logging.warning(\"occurrence parameter was set to False while adding an orientation observation.\"\\\n",
    "            \"This is weird because it would imply the measure was taken but the rock couldn't be observed.\"\\\n",
    "            \"Did you intend to avoid recording the occurrence, in which case you should prefer None isntead of False.\")\n",
    "        \n",
    "        if observed_object is not None: kargs[\"geology\"]= observed_object\n",
    "        if (dip is not None) and (dip_dir is not None):\n",
    "            kargs[\"dip\"]= dip\n",
    "            kargs[\"dip_dir\"]= dip_dir\n",
    "        self.add_observation(name, update_extension= update_extension, **kargs)\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.get_observations())\n",
    "         \n",
    "    def __str__(self):\n",
    "        \"\"\"Description of the dataset\n",
    "        \"\"\"\n",
    "        desc= [\"A dataset of type: {:s}\".format(type(self).__name__)]\n",
    "        n = len(self)\n",
    "        if n == 0:\n",
    "            desc+= [\"- The dataset is empty\"]\n",
    "        else:\n",
    "            desc+= [\"- Size of dataset: {:d}\".format(n)]\n",
    "            desc+= [\"- Types of data:\"]\n",
    "            desc+= [\" |- occurrence:\\t{} entries\".format(len(self.get_occurrence_observations()))]\n",
    "            desc+= [\" |- orientation:\\t{} entries\".format(len(self.get_orientation_observations()))]\n",
    "        if self.extension is None:\n",
    "            desc+= [\"- Extension: \"+str(self.extension)]\n",
    "        else:\n",
    "            desc+= [\"- Extension:\"]\n",
    "            labels = self.physical_space.coordinate_labels if self.physical_space is not None else [\"Coord_{}\".format(i) for i in range(3)][:len(self.extension)]\n",
    "            for dim_i, lim_i in zip(labels,self.extension):\n",
    "                desc+= [\" |- Coord {}: [{}, {}]\".format(dim_i, *lim_i)]  \n",
    "        desc+= [\"- Number of spaces this dataset is attached to: {:d}\".format(len(self.representation_spaces))]\n",
    "        if self.physical_space is None:\n",
    "            desc+= [\" |- Physical space: None\"]\n",
    "        else:\n",
    "            desc+= [\" |- Physical space:\"+\"\\n | |\".join(self.physical_space.__str__().split(\"\\n\"))]\n",
    "        if self.time_space is None:\n",
    "            desc+= [\" |- Temporal space: None\"]\n",
    "        else:\n",
    "            desc+= [\" |- Temporal space:\"+\"\\n | |\".join(self.time_space.__str__().split(\"\\n\"))]\n",
    "        return \"\\n\".join(desc) \n",
    "    \n",
    "    def head(self, n:int= 5):\n",
    "        \"\"\"Returns the `n`first data in the dataset\"\"\"\n",
    "        return self.to_dataframe(max_rows=n)\n",
    "    \n",
    "    def info(self):\n",
    "        \"\"\"Returns a description of the dataset\"\"\"\n",
    "        return self.__str__()\n",
    "    \n",
    "    def to_dataframe(self, max_rows:int= None):\n",
    "        \"\"\"Creates a `pandas.DataFrame` showing the data in this dataset\n",
    "        \n",
    "        Parameters:\n",
    "        - max_rows: limits the number of rows in the output, unless None is given (default).\n",
    "        Note: interanlly, all the observations are still recovered from the internal ontology, \n",
    "        but only the `max_rows`first ones are show for consision.\n",
    "        \"\"\"\n",
    "        columns = [\"name\"]\n",
    "        if self.physical_space is not None:\n",
    "            columns += self.physical_space.coordinate_labels\n",
    "        if self.time_space is not None:\n",
    "            columns += self.time_space.coordinate_labels\n",
    "        columns += [\"dip_dir\",\"dip\",'geology', 'occurrence']\n",
    "        output_frame = pd.DataFrame(columns= columns)\n",
    "        output_frame.set_index(\"name\",inplace=True)\n",
    "        \n",
    "        observations = self.get_observations() \n",
    "        observations = observations if max_rows is None else observations[:max_rows]\n",
    "        for di in observations:\n",
    "            for prop in di.get_properties():\n",
    "                if prop.name == '': continue\n",
    "                if \"coord\" in prop.name: continue\n",
    "                output_frame.loc[di.name,prop.name] = prop[di][0]\n",
    "                \n",
    "            if self.physical_space is not None:\n",
    "                for label, val in zip(self.physical_space.coordinate_labels, self.physical_space.get_object_coordinates(di)):\n",
    "                    output_frame.loc[di.name,label] = val\n",
    "            if self.time_space is not None:\n",
    "                for label, val in zip(self.time_space.coordinate_labels, self.time_space.get_object_times(di)):\n",
    "                    output_frame.loc[di.name,label] = val\n",
    "        coordinate_types = {label:float for label in self.physical_space.coordinate_labels} if self.physical_space is not None else {}\n",
    "        time_types = {label:float for label in self.physical_space.coordinate_labels} if self.time_space is not None else {}\n",
    "        other_types = {'dip_dir':float, 'dip':float, 'geology':str, \"occurrence\": bool}\n",
    "        output_frame = output_frame.astype({**coordinate_types, **other_types})\n",
    "        return output_frame\n",
    "    \n",
    "def load_dataset_from_csv(source:str, dataset:GeologicalDataset = None, coordinate_labels = [\"X\",\"Y\",\"Z\"], **kargs) ->GeologicalDataset:\n",
    "    \"\"\"Loads a dataset from a csv file\n",
    "    \n",
    "    Parameters:\n",
    "    - source(str): the source file from which the data should be loaded\n",
    "    - dataset: the `GeologicalDataset` in which the data will be loaded. If None, the dataset will be created.\n",
    "    - **arkgs: passed to pandas.read_csv\n",
    "    \n",
    "    Return:\n",
    "    - the `GeologicalDataset` with the newly loaded data (a new `GeologicalDataset` is created if needed).\"\"\"\n",
    "    try:\n",
    "        dataframe = pd.read_csv(source, **filter_kargs(pd.read_csv,**kargs))\n",
    "    except Exception as e:\n",
    "        raise( Exception(\"This error occurred while loading a dataset from: {}\\nAdditional arguments were given: {}\".format(source,\n",
    "                            \",\".join([\"{}:{}\".format(key,val) for key, val in kargs.items()]))))\n",
    "        \n",
    "    coordinate_labels = [label for label in coordinate_labels if label in dataframe.columns]\n",
    "    if len(coordinate_labels) == 0:\n",
    "        logging.warning(\"There isn't any coordinate column in the loaded dataset.\\nCheck the output and consider changing the separator with sep keyword or cahnge 'coordinate_label' parameter.\")\n",
    "    return load_dataset_from_dataframe(dataframe, dataset, coordinate_labels= coordinate_labels, **filter_kargs(load_dataset_from_dataframe,**kargs) )\n",
    "\n",
    "def load_dataset_from_dataframe(dataframe, \n",
    "                                dataset:GeologicalDataset = None, \n",
    "                                coordinate_labels = [\"X\",\"Y\",\"Z\"], labels= None, index= None, \n",
    "                                dtypes= None, clear_existing_data= True):\n",
    "    \"\"\"Loads a dataset from a `pandas.DataFrame`\n",
    "    \n",
    "    Parameters:\n",
    "    - dataframe(`pandas.DataFrame`): the source dataframe from which the data should be loaded\n",
    "    - dataset: the `GeologicalDataset` in which the data will be loaded. If None, the dataset will be created.\n",
    "    - coordinate_labels: the labels to be used as coordinates of the physical space\n",
    "    - labels: a dict to relabel the dataframe columns prior to loading in the dataset.\n",
    "    This is usefull for example when the coordinates in the source aren't labelled the same as in the internal ontology.\n",
    "    The format is {\"old_label\":\"new_label\", ...}.\n",
    "    - index: the label of the column (in original DataFrame, i.e., before renaming), which is to be used as index\n",
    "    - dtypes: a dict containing a mapping between column name and type\n",
    "    - clear_existing_data: if set (default), any oservation stored in the internal ontology is removed prior to loading the new dataset \n",
    "    \n",
    "    Return:\n",
    "    - the `GeologicalDataset` with the newly loaded data (a new `GeologicalDataset` is created if needed).\"\"\"\n",
    "    if dataset is None:\n",
    "        physical_space = PhysicalRepresentationSpace(coordinate_labels= coordinate_labels)\n",
    "        dataset = GeologicalDataset(physical_space = physical_space)\n",
    "    else:\n",
    "        if dataset.physical_space is None or clear_existing_data:\n",
    "            physical_space = PhysicalRepresentationSpace(coordinate_labels= coordinate_labels)\n",
    "            dataset.setup_representation_space(physical_space = physical_space)\n",
    "        else:\n",
    "            if dataset.physical_space.coordinate_labels != coordinate_labels:\n",
    "                raise MalissiaBaseError(\"Trying to add data into an existing dataset with different coordiante labels\")\n",
    "                \n",
    "    if clear_existing_data:\n",
    "        dataset.remove_all_observations()\n",
    "\n",
    "    # declare default dtypes here, in case they should be relabelled\n",
    "    default_coord_types = {key:float for key in dataset.physical_space.coordinate_labels}\n",
    "    other_types = {'dip_dir':float, 'dip':float, 'geology':str, \n",
    "                   'observed_object':str, \"occurrence\":bool}\n",
    "    dtypes= dtypes if dtypes is not None else {**default_coord_types, **other_types}\n",
    "    assert isinstance(dtypes, dict), \"dtypes for type management should be given as a dict\"\n",
    "    \n",
    "    # relabelling\n",
    "    if labels is not None:\n",
    "        dataframe = dataframe.rename(columns= labels)\n",
    "        index= labels[index] if index in labels else index\n",
    "        dtypes= {labels[key] if key in labels else key: value for key, value in dtypes.items()}\n",
    "    \n",
    "    # setting the index\n",
    "    if index is not None:\n",
    "        # if already set, reset it\n",
    "        if type(dataframe.index) != pd.core.indexes.base.Index:\n",
    "            dataframe = dataframe.reset_index()\n",
    "        # then set the index\n",
    "        try:\n",
    "            dataframe = dataframe.set_index(index)\n",
    "        except Exception as e:\n",
    "            raise( Exception(\"Error while setting the index of the loaded dataset:\\nThis is how the dataframe looks like:\\n\"+dataframe.head().to_string()))\n",
    "    \n",
    "    for extra_type_i in dtypes.keys() - set(dataframe.columns):\n",
    "        del dtypes[extra_type_i]\n",
    "    dataframe = dataframe.astype(dtypes)\n",
    "        \n",
    "    for name_i, values_i in dataframe.iterrows():\n",
    "        # drop nan values and filter None objects\n",
    "        values_i = {key:val for key, val in values_i.dropna().items() if val is not None}\n",
    "        dataset.add_observation(name_i, **values_i, update_extension= False)\n",
    "    dataset.update_extension()\n",
    "    \n",
    "    # resetting the default size when all data are loaded if not specified\n",
    "    if \"size\" not in dataframe:\n",
    "        size = max(physical_space.get_size())\n",
    "        for di in dataset.get_observations():\n",
    "            di.size = [float(size/20)]\n",
    "    \n",
    "    return dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import inspect\n",
    "\n",
    "def remove_kargs(keys,**kargs):\n",
    "    if isinstance(keys,list):\n",
    "        for key in keys:\n",
    "            if key in kargs:\n",
    "                del kargs[key]\n",
    "    else:\n",
    "        if keys in kargs:\n",
    "            del kargs[keys]\n",
    "    return kargs \n",
    "\n",
    "def filter_kargs(target_function,**kargs):\n",
    "    \"\"\"Helper function to filter keyword arguments and only pass the needed ones in a function signature\"\"\"\n",
    "    sig = inspect.signature(target_function)\n",
    "    # check if there is a **kargs in the signature of the function, if yes it is ok as it will take care of the passed extra kargs\n",
    "    if not any(p.kind == p.VAR_KEYWORD for p in sig.parameters.values()):\n",
    "        extra_args = kargs.keys() - sig.parameters.keys()\n",
    "        for args in extra_args:\n",
    "            del kargs[args]\n",
    "    return kargs\n",
    "\n",
    "def debuf_karg_filter(target_function, **kargs):\n",
    "    print(\"Kargs filtering:\")\n",
    "    print(\"before: {\",*[\"{}:{}\".format(key,val) for key, val in kargs.items()],\"}\")\n",
    "    print(\"after: {\",\",\".join([\"{}:{}\".format(key,val) for key, val in filter_kargs(target_function,**kargs).items()]),\"}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'sep': ';'}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "filter_kargs(pd.read_csv, **{\"sep\":\";\", \"truc\":\"test\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a dataset\n",
    "\n",
    "Data are actually described within the ontology, here thanks to the *Data* class.<br>\n",
    "Adding new data points calls for creating new *Data* individuals (i.e., instances in the ontology). (see demos below, section datasets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data visualisation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Data visualisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_line(center, dip, dir, length= 1, ax= None, color = \"black\", **kargs):\n",
    "    ax_plt = plt if ax is None else ax\n",
    "\n",
    "    center = np.array(center)\n",
    "    dip_rad = np.deg2rad(dip)\n",
    "    vec_x =  np.cos(dip_rad)\n",
    "    if dir == \"left\": vec_x *= -1\n",
    "    vec_z = -np.sin(dip_rad)\n",
    "    vect = 0.5 * length * np.array([vec_x,vec_z])\n",
    "    start = center - vect\n",
    "    end = center + vect\n",
    "    ax_plt.plot([start[0],end[0]],[start[1],end[1]], color = color, **kargs)\n",
    "    \n",
    "    return vect\n",
    "    \n",
    "def draw_dip_symbol(center, dip, dir, length= 1, polarity= None, ax= None, color = \"black\", polarity_ratio= 0.4, **kargs):\n",
    "    ax_plt = plt if ax is None else ax\n",
    "    \n",
    "    vect = draw_line(center= center, dip= dip, dir= dir, length= length, ax= ax_plt, color = color, **kargs)\n",
    "    \n",
    "    if polarity is not None:\n",
    "        vect_pol = polarity_ratio * np.array([-vect[1],vect[0]])\n",
    "        if (dir == \"left\" and polarity == \"up\") or (dir == \"right\" and polarity == \"down\") : vect_pol *= -1\n",
    "        ax_plt.arrow(*center,*vect_pol, width=length/100, color = color, **kargs)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Object implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "class RenderingObject(object):\n",
    "    \"\"\"Class dedicated to rendering a `RepresentationSpace`\"\"\"\n",
    "    registered_drawing_methods = {}\n",
    "    \n",
    "    def __init__(self, space:RepresentationSpace):\n",
    "        \"\"\"Creating a rendering for the given `RepresentationSpace`\"\"\"\n",
    "        self.space = space\n",
    "\n",
    "    @classmethod\n",
    "    def register_drawing_method(cls, object_or_class, drawing_method):\n",
    "        \"\"\"Registers a drawing function for the given  `object`\n",
    "        \"\"\"\n",
    "        if (object_or_class is None):\n",
    "            raise MalissiaBaseError(\"Registering drawing method for an undefined object class.\")\n",
    "        if drawing_method is None: raise MalissiaBaseError(\"Registering  an undefined drawing method for an object class.\")\n",
    "        \n",
    "        object_class = object_or_class if isinstance(object_or_class,type) else type(object_or_class) \n",
    "        cls.registered_drawing_methods[object_class] = drawing_method\n",
    "        \n",
    "    @classmethod\n",
    "    def get_drawing_method(cls, self, object_or_class):\n",
    "        \"\"\"Accessor to the drawing method for a given object\n",
    "        \n",
    "        Parameters:\n",
    "        - object_class_name (str): is the name of the class of the object to be drawned\n",
    "        \"\"\"\n",
    "        if (object_or_class is None):\n",
    "            raise MalissiaBaseError(\"Drawing methods are registered by object type. None was given, please give in a valid class.\")\n",
    "        \n",
    "        \n",
    "        if isinstance(object_or_class,type) :\n",
    "            return cls.registered_drawing_methods[object_or_class]\n",
    "        \n",
    "        elif isinstance(object_or_class, owl.Thing):\n",
    "            object_class = self.get_drawable_class_indiv(object_or_class)\n",
    "            if object_class :\n",
    "                return cls.registered_drawing_methods[object_class]\n",
    "            else:\n",
    "                raise MalissiaBaseError(\"No drawing method registered for this object: \"+ str(object_or_class))\n",
    "        \n",
    "        elif isinstance(object_or_class, list):\n",
    "            object_class = self.get_drawable_class_list(object_or_class)\n",
    "            if object_class :\n",
    "                return cls.registered_drawing_methods[object_class]\n",
    "            else:\n",
    "                raise MalissiaBaseError(\"No drawing method registered for this list_of_classes: \"+ str(object_or_class))\n",
    "        \n",
    "        object_class = object_or_class if isinstance(object_or_class,type) else type(object_or_class) \n",
    "        if object_class not in cls.registered_drawing_methods:\n",
    "            raise MalissiaBaseError(\"No drawing method registered for this class: \"+ str(object_class))\n",
    "        return cls.registered_drawing_methods[object_class]\n",
    "    \n",
    "\n",
    "    def get_drawable_class_indiv(self, individual):\n",
    "        \"\"\" this method returns the first drawble class of a given individual, assuming that the individual will have the same representation\n",
    "        using any drawing method associated with its classes. It retunrs None if no drawable method is found\"\"\"\n",
    "\n",
    "        for class_i in individual.is_a:\n",
    "            if class_i in self.registered_drawing_methods:\n",
    "                return class_i\n",
    "            else :\n",
    "                return None\n",
    "            \n",
    "    def get_drawable_class_list(self, individual_is_a_list):\n",
    "        \"\"\" this method returns the first drawble class of a list of classes of an individual (individual_is_a_list = indiidual.is_a)\n",
    "        assuming that the individual will have the same representation using any drawing method associated with its classes. \n",
    "        It retunrs None if no drawable method is found\"\"\"\n",
    "\n",
    "        for class_i in individual_is_a_list:\n",
    "            if class_i in self.registered_drawing_methods:\n",
    "                return class_i\n",
    "            else :\n",
    "                return None\n",
    "                \n",
    "\n",
    "\n",
    "        \n",
    "    def draw(self, object, **kargs):\n",
    "        self.get_drawing_method(object_or_class = object, self= self)(object, self, **kargs)\n",
    "        \n",
    "    def setup_ax(self, ax= None):\n",
    "            if ax is not None:\n",
    "                self.plt_ax = ax\n",
    "            elif self.plt_ax is None:\n",
    "                self.plt_ax = plt\n",
    "                \n",
    "    # def draw_interpreted_objects(self, ax= None, setup_drawing= True, **kargs):\n",
    "    #     if setup_drawing: self.setup_drawing(ax)\n",
    "        \n",
    "    #     for object_i in self.space.get_interpreted_objects():\n",
    "    #         object_class_name = type(object_i).name\n",
    "    #         drawing_method = self.get_drawing_method(object_class_name)\n",
    "    #         drawing_method(object_i, representation_space= self, ax= ax, setup_drawing= False, **kargs)\n",
    "                \n",
    "class AxisAlignedCrossSection(RenderingObject):\n",
    "    \"\"\"A specialised `Rendering` that procudes a cross-section.\n",
    "    \n",
    "    The cross-section is defined by two coordinates of the rendered `PhysicalRepresentationSpace`\"\"\"\n",
    "    registered_drawing_methods = {}\n",
    "    \n",
    "    def __init__(self, space:PhysicalRepresentationSpace, u= None, v= None, ax= None):\n",
    "        \"\"\"Creates a cross section through the given physical space\n",
    "        \n",
    "        Parameters:\n",
    "        - space: the space through which the cross section is going.\n",
    "        Note: the given space must be a `PhysicalRepresentationSpace` and have two or more coordinates\n",
    "        - u: the label of the abscissa axis among the physical space coordinates.\n",
    "        By default, if None is given, the first axis of the space is used.\n",
    "        - v: the label of the ordinate axis among the physical space coordinates.\n",
    "        By default, if None is given, the last axis of the space is used,\n",
    "        effectively using both coordinates if the space is 2D, but a vertical cross-section if it is 3D.\n",
    "        - ax: the matplotlib axis in which the space is to be rendered.\n",
    "        If None (default), then a new axis will be created.\"\"\"\n",
    "        assert isinstance(space,PhysicalRepresentationSpace), \"The given representation space must be a PhysicalRepresentationSpace, here: \"+str(type(space))\n",
    "        assert space.dimension > 1, \"Cross sections are only possible through spaces of dimensions >=2, here: \"+str(space.dimension)\n",
    "        self.space = space\n",
    "        \n",
    "        if u is None:\n",
    "            self.u = self.space.coordinate_labels[0]\n",
    "            self.u_index = 0\n",
    "        else:\n",
    "            assert u in self.space.coordinate_labels, \"The first given coordinate (u={}) is not in the represented space ({})\".format(u, \",\".join(space.coordinate_labels))\n",
    "            self.u = u\n",
    "            self.u_index = np.argwhere(self.space.coordinate_labels == self.u)[0,0]\n",
    "        \n",
    "        if v is None:\n",
    "            self.v = space.coordinate_labels[-1]\n",
    "            self.v_index = len(space.coordinate_labels) - 1\n",
    "        else:\n",
    "            assert v in space.coordinate_labels, \"The second given coordinate (v={}) is not in the represented space ({})\".format(v, \",\".join(space.coordinate_labels))\n",
    "            self.v = v\n",
    "            self.v_index = np.argwhere(self.space.coordinate_labels == self.v)[0,0]\n",
    "            \n",
    "        self.plt_ax = None\n",
    "                \n",
    "    def setup_drawing(self, ax= None):\n",
    "            self.setup_ax(ax)\n",
    "            \n",
    "            ax = self.plt_ax.gca() if self.plt_ax == plt else self.plt_ax\n",
    "            ax.set_aspect(\"equal\")\n",
    "            ax.set_xlim( *self.space.extension[self.u_index])\n",
    "            ax.set_xlabel(self.u)\n",
    "            ax.set_ylim( *self.space.extension[self.v_index])\n",
    "            ax.set_ylabel(self.v)\n",
    "    \n",
    "    def draw_segment(self, from_coord, to_coord, **kargs):\n",
    "        self.plt_ax.plot(\n",
    "            [from_coord[0],to_coord[0]],\n",
    "            [from_coord[1],to_coord[1]],\n",
    "            **filter_kargs(self.plt_ax.plot,**kargs)\n",
    "            )\n",
    "        \n",
    "    def draw_line(self, center, dip, dir, length= 1, color = \"black\", setup_drawing= True, ax= None, **kargs):\n",
    "        if setup_drawing: self.setup_drawing(ax)\n",
    "        \n",
    "        center = np.array(center)\n",
    "        dip_rad = np.deg2rad(dip)\n",
    "        vec_x =  np.cos(dip_rad)\n",
    "        if dir == \"left\": vec_x *= -1\n",
    "        vec_z = -np.sin(dip_rad)\n",
    "        vect = 0.5 * length * np.array([vec_x,vec_z])\n",
    "        start = center - vect\n",
    "        end = center + vect\n",
    "        self.draw_segment(from_coord= start, to_coord= end, color = color, **kargs)\n",
    "        \n",
    "        return vect\n",
    "    \n",
    "    def draw_dip_symbol(self, data= None, dip= None, dip_dir= None, center= None,\n",
    "                        length= None, polarity= \"up\", color = \"black\", polarity_ratio= 0.4, setup_drawing= True, ax= None, zorder= 20, **kargs):\n",
    "        if setup_drawing: self.setup_drawing(ax)\n",
    "\n",
    "        dip = data.dip[0] if data is not None else dip\n",
    "        dip_dir = data.dip_dir[0] if data is not None else dip_dir\n",
    "        dir = \"right\" if dip_dir < 180 else \"left\"\n",
    "        center = self.get_center_coordinates(data) if data is not None else center\n",
    "        \n",
    "        length = data.size[0] if (data is not None) and (data.size is not None) else length\n",
    "        if length is None or length is np.nan:\n",
    "            length = np.abs(np.max(self.space.extension[:,1] - self.space.extension[:,0])) / 20\n",
    "        \n",
    "        vect = self.draw_line(center= center, dip= dip, dir= dir, length= length, color = color, setup_drawing=False, ax=ax, zorder= zorder, **kargs)\n",
    "        \n",
    "        if (data is not None) and (data.polarity is not None):\n",
    "            polarity = \"up\" if data.polarity[0] else \"down\"\n",
    "        if polarity is not None:\n",
    "            vect_pol = polarity_ratio * np.array([-vect[1],vect[0]])\n",
    "            if (dir == \"left\" and polarity == \"up\") or (dir == \"right\" and polarity == \"down\") : vect_pol *= -1\n",
    "            self.plt_ax.arrow(*center,*vect_pol, width=length/100, color = color,  zorder= zorder, **filter_kargs(self.plt_ax.arrow,**kargs))\n",
    "        \n",
    "    def filter_section_coordinates(self, coord):\n",
    "        return coord[[self.u_index,self.v_index]]\n",
    "        \n",
    "    def get_center_coordinates(self,di):\n",
    "        coord = self.space.get_object_coordinates(di, kind= \"center\")\n",
    "        return self.filter_section_coordinates(coord)\n",
    "    \n",
    "    def get_normal_coordinates(self,di):\n",
    "        coord = self.space.get_object_coordinates(di, kind= \"normal\")\n",
    "        return self.filter_section_coordinates(coord)\n",
    "    \n",
    "    def get_corner_coordinates(self, surf):\n",
    "        coord = self.space.get_object_coordinates(surf, kind= \"nodes\")\n",
    "        return self.filter_section_coordinates(coord.T)\n",
    "    \n",
    "    def draw_dip_data(self, ax= None, polarity= \"up\", setup_drawing= True, **kargs):\n",
    "        if setup_drawing: self.setup_drawing(ax)\n",
    "        \n",
    "        for dataset_i in self.space.get_datasets():\n",
    "            for di in dataset_i.get_orientation_observations():\n",
    "                self.draw_dip_symbol(data = di, setup_drawing= False, ax=ax, **kargs) \n",
    "    \n",
    "    def draw_point(self, center= None, data = None, color = \"black\", marker=\"*\", edge_color= \"black\", zorder= 10, \n",
    "                                                        setup_drawing= True, ax= None, **kargs):\n",
    "        if setup_drawing: self.setup_drawing(ax)\n",
    "        \n",
    "        center = self.get_center_coordinates(data) if data is not None else center\n",
    "        self.plt_ax.scatter(*center, color = color, marker= marker, edgecolors= edge_color, zorder=zorder, **filter_kargs(self.plt_ax.scatter,**kargs))\n",
    "        \n",
    "    def draw_plane(self, plane, color = \"limegreen\", marker=\".\", edge_color= \"black\", \n",
    "                   draw_normal= False, zorder= 2, setup_drawing= True, ax= None, **kargs):\n",
    "        if setup_drawing: self.setup_drawing(ax)\n",
    "        \n",
    "        corner_coords = self.get_corner_coordinates(plane)\n",
    "        self.plt_ax.scatter(*corner_coords, color = color, marker= marker, edgecolors= edge_color, zorder=zorder, **filter_kargs(self.plt_ax.scatter,**kargs))\n",
    "        \n",
    "        plane_coords = np.append(corner_coords,corner_coords[:,0].reshape((2,1)),axis=1)\n",
    "        self.plt_ax.plot(*plane_coords, color = color, marker= None, zorder=zorder-1, **filter_kargs(self.plt_ax.plot,**kargs))\n",
    "\n",
    "        if draw_normal:\n",
    "            center = np.array(self.get_center_coordinates(plane))\n",
    "            normal = np.array(self.get_normal_coordinates(plane))\n",
    "            length = spatial.distance.pdist(corner_coords.T, metric=\"euclidean\").max()\n",
    "            end = center + 0.05 * length * normal\n",
    "            self.draw_segment(center, end, color = color, marker= None, zorder=zorder-1, **kargs)\n",
    "\n",
    "\n",
    "    def draw_multiple_planes(self, list_of_planes, color = \"olivedrab\", marker=\".\", edge_color= \"black\", \n",
    "                   draw_normal= False, zorder= 2, setup_drawing= True, ax= None, **kargs):\n",
    "        if setup_drawing: self.setup_drawing(ax)\n",
    "        \n",
    "        for plane in list_of_planes:\n",
    "            corner_coords = self.get_corner_coordinates(plane)\n",
    "            self.plt_ax.scatter(*corner_coords, color = color, marker= marker, edgecolors= edge_color, zorder=zorder, **filter_kargs(self.plt_ax.scatter,**kargs))\n",
    "            \n",
    "            plane_coords = np.append(corner_coords,corner_coords[:,0].reshape((2,1)),axis=1)\n",
    "            self.plt_ax.plot(*plane_coords, color = color, marker= None, zorder=zorder-1, **filter_kargs(self.plt_ax.plot,**kargs))\n",
    "\n",
    "            if draw_normal:\n",
    "                center = np.array(self.get_center_coordinates(plane))\n",
    "                normal = np.array(self.get_normal_coordinates(plane))\n",
    "                length = spatial.distance.pdist(corner_coords.T, metric=\"euclidean\").max()\n",
    "                end = center + 0.05 * length * normal\n",
    "                self.draw_segment(center, end, color = color, marker= None, zorder=zorder-1, **kargs)\n",
    "\n",
    "    \n",
    "    def draw_explanation(self, explained_object, projection, color= \"k\",\n",
    "                         highlight_explained_object= False, highlight_linewidth= 3,\n",
    "                         zorder= 3, linestyle= \"dashed\", **kargs):\n",
    "        center_object = self.get_center_coordinates(explained_object)\n",
    "        projection = self.filter_section_coordinates(projection)\n",
    "        self.draw_segment(center_object, projection, color= color, linestyle= linestyle)\n",
    "        \n",
    "        if highlight_explained_object:\n",
    "            self.draw(explained_object,zorder= zorder+1,\n",
    "                        path_effects=[patheffects.withStroke(foreground=color, linewidth= highlight_linewidth)]\n",
    "                      )\n",
    "    \n",
    "    def draw_occurrence_symbol(self, center= None, data = None, color = \"lightblue\", marker=\"o\", edge_color= \"black\", zorder= 20, setup_drawing= True, ax= None, **kargs):\n",
    "        if setup_drawing: self.setup_drawing(ax)\n",
    "        self.draw_point( center= center, data = data,  color= color, marker= marker, edge_color= edge_color, zorder=zorder, setup_drawing= False, ax=ax, **kargs) \n",
    "        \n",
    "    def draw_occurrence_data(self, ax= None, setup_drawing= True, **kargs):\n",
    "        if setup_drawing: self.setup_drawing(ax)\n",
    "        \n",
    "        for dataset_i in self.space.get_datasets():\n",
    "            for di in dataset_i.get_occurrence_observations():\n",
    "                self.draw_occurrence_symbol(data= di, setup_drawing= False, ax=ax, **kargs) \n",
    "            \n",
    "    def draw_interpreted_objects(self, ax= None, setup_drawing= True, **kargs):\n",
    "        if setup_drawing: self.setup_drawing(ax)\n",
    "        \n",
    "        for obj_i in self.space.get_interpreted_objects():\n",
    "            self.draw(obj_i, ax= ax, setup_drawing= False, **kargs) \n",
    "            \n",
    "    def draw_relation(self, obj1, obj2, ax= None, setup_drawing= True, color= \"black\", **kargs):\n",
    "        if setup_drawing: self.setup_drawing(ax)\n",
    "        \n",
    "        obj1_nodes = self.get_corner_coordinates(obj1).T\n",
    "        obj2_nodes = self.get_corner_coordinates(obj2).T\n",
    "        dist = spatial.distance.cdist(obj1_nodes, obj2_nodes, \"euclidean\")\n",
    "        index_from, index_to = np.unravel_index(np.argmin(dist), shape= dist.shape)\n",
    "        self.draw_segment(obj1_nodes[index_from], obj2_nodes[index_to], color= color, **kargs)\n",
    "        \n",
    "    def show(self, ax= None, setup_drawing= True, show_objects= True, **kargs):\n",
    "        if setup_drawing: self.setup_drawing(ax)\n",
    "        self.draw_occurrence_data(ax=ax, setup_drawing= False, **kargs)\n",
    "        self.draw_dip_data(ax=ax, setup_drawing= False, **kargs)\n",
    "        if show_objects:\n",
    "            self.draw_interpreted_objects(ax=ax, setup_drawing= False, **kargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Drawing methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "GeologicalKnowledgeManager().load_knowledge_framework()\n",
    "mogi = GeologicalKnowledgeManager().get_knowledge_framework()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def draw_observation_in_AxisAlignedCrossSection(\n",
    "        observation,\n",
    "        drawing_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        **kargs\n",
    "    ):\n",
    "    if setup_drawing:\n",
    "        drawing_space.setup_drawing(ax)\n",
    "    else:\n",
    "        drawing_space.setup_ax(ax)\n",
    "        \n",
    "    if (observation.occurrence is not None) and (len(observation.occurrence)>0) :\n",
    "        drawing_space.draw_occurrence_symbol(data= observation, ax= ax, setup_drawing= False, **kargs)\n",
    "    if (observation.dip is not None) and (len(observation.dip)>0):\n",
    "        drawing_space.draw_dip_symbol(data= observation, ax= ax, setup_drawing= False, **kargs)\n",
    "        \n",
    "if mogi().PointBased_Observation in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().PointBased_Observation]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().PointBased_Observation, draw_observation_in_AxisAlignedCrossSection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_dataset_in_AxisAlignedCrossSection(\n",
    "        dataset: GeologicalDataset,\n",
    "        drawing_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        **kargs\n",
    "    ):\n",
    "    if setup_drawing:\n",
    "        drawing_space.setup_drawing(ax)\n",
    "    else:\n",
    "        drawing_space.setup_ax(ax)\n",
    "            \n",
    "    # draw created objects\n",
    "    for d_i in dataset.get_observations():\n",
    "        drawing_space.draw(d_i, setup_drawing= False, **kargs)\n",
    "        \n",
    "if GeologicalDataset in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[GeologicalDataset]\n",
    "AxisAlignedCrossSection.register_drawing_method(GeologicalDataset, draw_dataset_in_AxisAlignedCrossSection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "def draw_fold_in_AxisAlignedCrossSection(\n",
    "        fold,\n",
    "        drawing_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        color = \"darkgreen\",\n",
    "        color_axi_surf = \"blue\",\n",
    "        draw_limbs_normal= False,\n",
    "        draw_axial_surface = True, \n",
    "        draw_axial_surface_normal = False,\n",
    "        draw_explanation= False,\n",
    "        draw_explained_objects_normal = None,\n",
    "        **kargs\n",
    "    ):\n",
    "\n",
    "    knowledge_framework = GeologicalKnowledgeManager().get_knowledge_framework()\n",
    "\n",
    "    if setup_drawing:\n",
    "        drawing_space.setup_drawing(ax)\n",
    "    else:\n",
    "        drawing_space.setup_ax(ax)\n",
    "    limb1 = fold.has_Limb1[0]\n",
    "    limb2 = fold.has_Limb2[0]    \n",
    "    plane1 = limb1.has_Representation[0]\n",
    "    drawing_space.draw_plane(plane1, color= color, draw_normal= draw_limbs_normal, **kargs)\n",
    "    plane2 = limb2.has_Representation[0]\n",
    "    drawing_space.draw_plane(plane2, color= color, draw_normal= draw_limbs_normal, **kargs)\n",
    "    if draw_axial_surface == True:\n",
    "        axial_surface = fold.has_Axial_Surface[0]\n",
    "        plane3 = axial_surface.has_Representation[0]\n",
    "        drawing_space.draw_plane(plane3, color= color_axi_surf, \n",
    "                                        draw_normal= draw_axial_surface_normal, **kargs)\n",
    "    \n",
    "    \n",
    "    if draw_explanation:\n",
    "        if (fold.explain is not None) and (len(fold.explain) > 0):\n",
    "            face1 = limb1.has_Representation[0]\n",
    "            face2 = limb2.has_Representation[0]\n",
    "            extreme_faces = [face1, face2]\n",
    "            space = drawing_space.space\n",
    "            n1 = space.get_object_coordinates(face1, \"normal\")\n",
    "            n2 = space.get_object_coordinates(face2, \"normal\")\n",
    "            vectors = [n1, n2]\n",
    "            plane = drawing_space(complex_surface = None, physical_space = space, \n",
    "                                   knowledge_framework = knowledge_framework, \n",
    "                                   vectors = vectors, extreme_faces= extreme_faces, force_computing_for_fold = True, fold = fold)\n",
    "\n",
    "            for explained_object in fold.explain:\n",
    "                \n",
    "                \n",
    "                # compute projection point\n",
    "                projection = drawing_space.space.compute_projection_on_plane(plane=plane, \n",
    "                                                                object= explained_object)\n",
    "                \n",
    "                # draw explanation link\n",
    "                drawing_space.draw_explanation(explained_object= explained_object, projection= projection,\n",
    "                                                      color= color, draw_normal= draw_explained_objects_normal,\n",
    "                                                      highlight_explained_object= True, **kargs )    \n",
    "    \n",
    "    \n",
    "if mogi().Fold in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().Fold]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().Fold, draw_fold_in_AxisAlignedCrossSection)\n",
    "\n",
    "if mogi().Chevron_Fold in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().Chevron_Fold]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().Chevron_Fold, draw_fold_in_AxisAlignedCrossSection)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "def draw_folding_train_in_AxisAlignedCrossSection(\n",
    "        folding_train,\n",
    "        drawing_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        color = \"darkgreen\",\n",
    "        color_axi_surf = \"blue\",\n",
    "        draw_limbs_normal= False,\n",
    "        draw_axial_surface = True, \n",
    "        draw_axial_surface_normal = False,\n",
    "        draw_explanation= False,\n",
    "        draw_explained_objects_normal = None,\n",
    "        **kargs\n",
    "    ):\n",
    "\n",
    "    knowledge_framework = GeologicalKnowledgeManager().get_knowledge_framework()\n",
    "    \n",
    "\n",
    "    if setup_drawing:\n",
    "        drawing_space.setup_drawing(ax)\n",
    "    else:\n",
    "        drawing_space.setup_ax(ax)\n",
    "\n",
    "    for fold in folding_train.has_Part:\n",
    "        limb1 = fold.has_Limb1[0]\n",
    "        limb2 = fold.has_Limb2[0]    \n",
    "        plane1 = limb1.has_Representation[0]\n",
    "        drawing_space.draw_plane(plane1, color= color, draw_normal= draw_limbs_normal, **kargs)\n",
    "        plane2 = limb2.has_Representation[0]\n",
    "        drawing_space.draw_plane(plane2, color= color, draw_normal= draw_limbs_normal, **kargs)\n",
    "        if draw_axial_surface == True:\n",
    "            axial_surface = fold.has_Axial_Surface[0]\n",
    "            plane3 = axial_surface.has_Representation[0]\n",
    "            drawing_space.draw_plane(plane3, color= color_axi_surf, \n",
    "                                            draw_normal= draw_axial_surface_normal, **kargs)\n",
    "        \n",
    "        \n",
    "        if draw_explanation:\n",
    "            if (fold.explain is not None) and (len(fold.explain) > 0):\n",
    "                face1 = limb1.has_Representation[0]\n",
    "                face2 = limb2.has_Representation[0]\n",
    "                extreme_faces = [face1, face2]\n",
    "                space = drawing_space.space\n",
    "                n1 = space.get_object_coordinates(face1, \"normal\")\n",
    "                n2 = space.get_object_coordinates(face2, \"normal\")\n",
    "                vectors = [n1, n2]\n",
    "                plane = drawing_space(complex_surface = None, physical_space = space, \n",
    "                                    knowledge_framework = knowledge_framework, \n",
    "                                    vectors = vectors, extreme_faces= extreme_faces, force_computing_for_fold = True, fold = fold)\n",
    "\n",
    "                for explained_object in fold.explain:\n",
    "                    \n",
    "                    \n",
    "                    # compute projection point\n",
    "                    projection = drawing_space.space.compute_projection_on_plane(plane=plane, \n",
    "                                                                    object= explained_object)\n",
    "                    \n",
    "                    # draw explanation link\n",
    "                    drawing_space.draw_explanation(explained_object= explained_object, projection= projection,\n",
    "                                                        color= color, draw_normal= draw_explained_objects_normal,\n",
    "                                                        highlight_explained_object= True, **kargs ) \n",
    "    if draw_explanation:\n",
    "        if (fold.explain is not None) and (len(fold.explain) > 0):\n",
    "            face1 = limb1.has_Representation[0]\n",
    "            face2 = limb2.has_Representation[0]\n",
    "            extreme_faces = [face1, face2]\n",
    "            space = drawing_space.space\n",
    "            n1 = space.get_object_coordinates(face1, \"normal\")\n",
    "            n2 = space.get_object_coordinates(face2, \"normal\")\n",
    "            vectors = [n1, n2]\n",
    "            plane = drawing_space(complex_surface = None, physical_space = space, \n",
    "                                knowledge_framework = knowledge_framework, \n",
    "                                vectors = vectors, extreme_faces= extreme_faces, force_computing_for_fold = True, fold = fold)\n",
    "\n",
    "            for explained_object in fold.explain:\n",
    "                \n",
    "                \n",
    "                # compute projection point\n",
    "                projection = drawing_space.space.compute_projection_on_plane(plane=plane, \n",
    "                                                                object= explained_object)\n",
    "                \n",
    "                # draw explanation link\n",
    "                drawing_space.draw_explanation(explained_object= explained_object, projection= projection,\n",
    "                                                    color= color, draw_normal= draw_explained_objects_normal,\n",
    "                                                    highlight_explained_object= True, **kargs )       \n",
    "    \n",
    "    \n",
    "if mogi().Fold_Train in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().Fold_Train]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().Fold_Train, draw_folding_train_in_AxisAlignedCrossSection)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_mean_plane_for_drawing(complex_surface, physical_space, \n",
    "                                   knowledge_framework, vectors = None, extreme_faces= None,\n",
    "                                     force_computing_for_fold = False, fold = None):\n",
    "    if force_computing_for_fold == True:\n",
    "        vectors = vectors\n",
    "        extreme_faces = extreme_faces\n",
    "    else:\n",
    "        if len(complex_surface.has_Part) < 2:\n",
    "            raise MalissiaBaseError('the complex_surface {} has less then two parts'.format(complex_surface.name))\n",
    "        vectors = [physical_space.get_object_coordinates(part,\n",
    "                     \"normal\") for part in complex_surface.has_Part ]\n",
    "        \n",
    "    vectors = np.array(vectors)\n",
    "    # Compute the mean along each axis\n",
    "    mean_vector = np.mean(vectors, axis=0)\n",
    "    dip, dip_dir = compute_dip_dir_from_normal(mean_vector) \n",
    "    center = compute_center_complex_surface(knowledge_framework, physical_space, \n",
    "                                            complex_surface, extreme_faces= extreme_faces, \n",
    "                                            force_computing_for_fold = force_computing_for_fold)\n",
    "    size = compute_size_complex_surface_for_representation(knowledge_framework, physical_space, \n",
    "                                                           complex_surface, extreme_faces= extreme_faces)\n",
    "    if force_computing_for_fold == True:\n",
    "        name = fold.name\n",
    "    else:\n",
    "        name = complex_surface.name\n",
    "    return constructor_planar_surface_from_center_attitude(knowledge_framework, physical_space.coordinate_labels, center, dip, dip_dir, size= size,\n",
    "                                                     polarity= True, name= 'plane of {} for projection'.format(name))\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def draw_stratigraphic_part_in_AxisAlignedCrossSection(\n",
    "        strati_part,\n",
    "        drawing_space, \n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        color = \"limegreen\",\n",
    "        draw_normal = False,\n",
    "        draw_explanation= False,\n",
    "        **kargs\n",
    "    ):\n",
    "\n",
    "    knowledge_framework = GeologicalKnowledgeManager().get_knowledge_framework()\n",
    "    if setup_drawing:\n",
    "        drawing_space.setup_drawing(ax)\n",
    "    else:\n",
    "        drawing_space.setup_ax(ax)\n",
    "    representation = strati_part.has_Representation[0]\n",
    "    \n",
    "    if knowledge_framework().Planar_Surface in representation.is_a :\n",
    "        drawing_space.draw_plane(representation, color= color, draw_normal= draw_normal, **kargs)\n",
    "        plane = representation   \n",
    "    \n",
    "    elif knowledge_framework().Complex_Surface in representation.is_a:\n",
    "        color = \"olivedrab\" if color == \"limegreen\" or color == None else color\n",
    "        drawing_space.draw_multiple_planes(representation.has_Part, color = color,  \n",
    "                   draw_normal= draw_normal, **kargs)\n",
    "            \n",
    "    space = drawing_space.space              \n",
    "    if draw_explanation:\n",
    "        if knowledge_framework().Complex_Surface in representation.is_a:\n",
    "            plane = compute_mean_plane_for_drawing(representation, \n",
    "                                               space, # must add getter of physical space from cplx_surf\n",
    "                                               knowledge_framework)\n",
    "\n",
    "        if (strati_part.explain is not None) and (len(strati_part.explain) > 0):\n",
    "            for explained_object in strati_part.explain:\n",
    "                \n",
    "                # compute projection point\n",
    "                projection = space.compute_projection_on_plane(plane=plane, object= explained_object)\n",
    "                \n",
    "                # draw explanation link\n",
    "                drawing_space.draw_explanation(explained_object= explained_object, projection= projection,\n",
    "                                                      color= color, draw_normal= draw_normal, \n",
    "                                                      highlight_explained_object= True, **kargs )\n",
    "        \n",
    "        \n",
    "if mogi().Stratigraphic_Part in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().Stratigraphic_Part]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().Stratigraphic_Part, draw_stratigraphic_part_in_AxisAlignedCrossSection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def draw_limb_in_AxisAlignedCrossSection(\n",
    "        strati_part,\n",
    "        drawing_space, \n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        color = \"limegreen\",\n",
    "        draw_normal = False,\n",
    "        draw_explanation= False,\n",
    "        **kargs\n",
    "    ):\n",
    "\n",
    "    knowledge_framework = GeologicalKnowledgeManager().get_knowledge_framework()\n",
    "    if setup_drawing:\n",
    "        drawing_space.setup_drawing(ax)\n",
    "    else:\n",
    "        drawing_space.setup_ax(ax)\n",
    "    representation = strati_part.has_Representation[0]\n",
    "    \n",
    "    if knowledge_framework().Planar_Surface in representation.is_a :\n",
    "        drawing_space.draw_plane(representation, color= color, draw_normal= draw_normal, **kargs)\n",
    "        plane = representation   \n",
    "    \n",
    "    elif knowledge_framework().Complex_Surface in representation.is_a:\n",
    "        color = \"olivedrab\" if color == \"limegreen\" or color == None else color\n",
    "        drawing_space.draw_multiple_planes(representation.has_Part, color = color,  \n",
    "                   draw_normal= draw_normal, **kargs)\n",
    "            \n",
    "    space = drawing_space.space            \n",
    "        \n",
    "    if draw_explanation:\n",
    "        if knowledge_framework().Complex_Surface in representation.is_a:\n",
    "            plane = compute_mean_plane_for_drawing(representation, \n",
    "                                               space, # must add getter of physical space from cplx_surf\n",
    "                                               knowledge_framework)\n",
    "\n",
    "        if (strati_part.explain is not None) and (len(strati_part.explain) > 0):\n",
    "            for explained_object in strati_part.explain:\n",
    "                \n",
    "                # compute projection point\n",
    "                projection = space.compute_projection_on_plane(plane=plane, object= explained_object)\n",
    "                \n",
    "                # draw explanation link\n",
    "                drawing_space.draw_explanation(explained_object= explained_object, projection= projection,\n",
    "                                                      color= color, draw_normal= draw_normal, \n",
    "                                                      highlight_explained_object= True, **kargs )\n",
    "        \n",
    "        \n",
    "if mogi().Fold_Limb in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().Fold_Limb]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().Fold_Limb, draw_limb_in_AxisAlignedCrossSection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def draw_situation_in_AxisAlignedCrossSection(\n",
    "        situation,\n",
    "        drawing_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        zorder= 100,\n",
    "        feature_color= 'deepskyblue',\n",
    "        feature_linewidth= 3,\n",
    "        explaining_color= 'orange',\n",
    "        explaining_linewidth= 4,\n",
    "        anomaly_color= 'red',\n",
    "        anomaly_linewidth= 5,\n",
    "        **kargs\n",
    "    ):\n",
    "    if setup_drawing:\n",
    "        drawing_space.setup_drawing(ax)\n",
    "    else:\n",
    "        drawing_space.setup_ax(ax)\n",
    "    \n",
    "    # remove any existing path effect for it to be overriden\n",
    "    if \"path_effects\" in kargs:\n",
    "        del kargs[\"path_effects\"]\n",
    "    \n",
    "    for feature_i in situation.features:\n",
    "        drawing_space.draw(feature_i,\n",
    "                              path_effects=[patheffects.withStroke(foreground= feature_color, linewidth= feature_linewidth)],\n",
    "                              ax = ax, setup_drawing= False, zorder= zorder, **kargs)\n",
    "        \n",
    "    if situation.explaining_object is not None:\n",
    "        drawing_space.draw(situation.explaining_object,\n",
    "                              path_effects=[patheffects.withStroke(foreground= explaining_color, linewidth= explaining_linewidth)],\n",
    "                              ax = ax, setup_drawing= False, zorder= zorder+1,  **kargs)\n",
    "        \n",
    "    if (situation.anomalies is not None) and (len(situation.anomalies) > 0):\n",
    "        for anomaly in situation.anomalies:\n",
    "            drawing_space.draw(anomaly,\n",
    "                            color = anomaly_color, linewidth= anomaly_linewidth,\n",
    "                              ax = ax, setup_drawing= False, zorder= zorder+2,  **kargs)\n",
    "        \n",
    "if InterpretationSituation in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[InterpretationSituation]\n",
    "AxisAlignedCrossSection.register_drawing_method(InterpretationSituation, draw_situation_in_AxisAlignedCrossSection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def draw_representation_anomaly_in_AxisAlignedCrossSection(\n",
    "        anomaly,\n",
    "        drawing_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        color = \"r\",\n",
    "        linewidth= 3,\n",
    "        zorder= 200,\n",
    "        **kargs\n",
    "    ):\n",
    "    if setup_drawing:\n",
    "        drawing_space.setup_drawing(ax)\n",
    "    else:\n",
    "        drawing_space.setup_ax(ax)\n",
    "    \n",
    "    # remove any existing path effect for it to be overriden\n",
    "    if \"path_effects\" in kargs:\n",
    "        del kargs[\"path_effects\"]\n",
    "    \n",
    "    if (anomaly.is_Related_To_Representation is not None) and (len(anomaly.is_Related_To_Representation) >0):\n",
    "        if anomaly.is_Related_To_Representation[0] in drawing_space.registered_drawing_methods:\n",
    "            drawing_space.draw(anomaly.is_Related_To_Representation[0],\n",
    "                              path_effects=[patheffects.withStroke(foreground= color, linewidth= linewidth)],\n",
    "                              ax = ax, setup_drawing= False, zorder= zorder,  **kargs)\n",
    "        else:\n",
    "            drawing_space.draw(anomaly.is_Related_To[0],\n",
    "                              path_effects=[patheffects.withStroke(foreground= color, linewidth= linewidth)],\n",
    "                              ax = ax, setup_drawing= False, zorder= zorder, **kargs)\n",
    "        \n",
    "if mogi().RepresentationAnomaly in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().RepresentationAnomaly]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().RepresentationAnomaly, draw_representation_anomaly_in_AxisAlignedCrossSection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def draw_representation_anomaly_fold_train_in_AxisAlignedCrossSection(\n",
    "        anomaly,\n",
    "        drawing_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        color = \"r\",\n",
    "        linewidth= 3,\n",
    "        zorder= 200,\n",
    "        **kargs\n",
    "    ):\n",
    "    if setup_drawing:\n",
    "        drawing_space.setup_drawing(ax)\n",
    "    else:\n",
    "        drawing_space.setup_ax(ax)\n",
    "    \n",
    "    # remove any existing path effect for it to be overriden\n",
    "    if \"path_effects\" in kargs:\n",
    "        del kargs[\"path_effects\"]\n",
    "\n",
    "    \n",
    "    \n",
    "    if anomaly.is_Related_To_Folding_Train is not None and len([anomaly.is_Related_To_Representation]) >0:\n",
    "        drawing_space.draw(anomaly.is_Related_To_Folding_Train,\n",
    "                              path_effects=[patheffects.withStroke(foreground= color, linewidth= linewidth)],\n",
    "                              ax = ax, setup_drawing= False, zorder= zorder,  **kargs)\n",
    "        \n",
    "if mogi().FoldTrainRepresentationAnomaly in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().FoldTrainRepresentationAnomaly]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().FoldTrainRepresentationAnomaly, draw_representation_anomaly_fold_train_in_AxisAlignedCrossSection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_dipping_stratigraphy_anomaly_in_AxisAlignedCrossSection(\n",
    "        anomaly,\n",
    "        drawing_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        draw_normal= False,\n",
    "        color = \"r\",\n",
    "        linewidth= 5,\n",
    "        zorder = 200,\n",
    "        **kargs\n",
    "    ):\n",
    "    if setup_drawing:\n",
    "        drawing_space.setup_drawing(ax)\n",
    "    else:\n",
    "        drawing_space.setup_ax(ax)\n",
    "    \n",
    "    # remove any existing path effect for it to be overriden\n",
    "    if \"path_effects\" in kargs:\n",
    "        del kargs[\"path_effects\"]\n",
    "    \n",
    "    drawing_space.draw(anomaly.is_Related_To[0],\n",
    "                              path_effects=[patheffects.withStroke(foreground= color, linewidth= linewidth)],\n",
    "                              ax = ax, setup_drawing= False, zorder= zorder,\n",
    "                              draw_normal= draw_normal, **kargs)\n",
    "        \n",
    "if mogi().DippingStratigraphyAnomaly in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().DippingStratigraphyAnomaly]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().DippingStratigraphyAnomaly, draw_dipping_stratigraphy_anomaly_in_AxisAlignedCrossSection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors as mcolors\n",
    "\n",
    "def get_shades_between_colors(color1, color2, num_shades):\n",
    "    cmap = mcolors.LinearSegmentedColormap.from_list('custom', [color1, color2], N=num_shades)\n",
    "    shades = [mcolors.rgb2hex(cmap(i)[:3]) for i in range(cmap.N)]\n",
    "    return shades\n",
    "\n",
    "def get_shade_names(shades):\n",
    "    shade_names = [mcolors.to_rgba(shade) for shade in shades]\n",
    "    return [mcolors.to_hex(color) for color in shade_names]\n",
    "\n",
    "def draw_shared_sides_size_cplx_sur_anomaly_in_AxisAlignedCrossSection(\n",
    "        anomaly,\n",
    "        representation_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        draw_normal= False,\n",
    "        bounding_color1 = \"red\", \n",
    "        bounding_color2 = \"blue\",\n",
    "        zorder = 200,\n",
    "        **kargs\n",
    "    ):\n",
    "    if setup_drawing:\n",
    "        representation_space.setup_drawing(ax)\n",
    "    else:\n",
    "        representation_space.setup_ax(ax)\n",
    "    if len(anomaly.is_Related_To) < 1 :\n",
    "        print('Warning: anomaly {} is not related to any complex_surface'.format(anomaly.name))\n",
    "        return None\n",
    "    \n",
    "    complex_surface = anomaly.is_Related_To[0]\n",
    "    if len(complex_surface.has_Part) < 2:\n",
    "        print('Warning: complex_surface {} related to the anomaly {} deos not have enough parts '.format(complex_surface.name, anomaly.name))\n",
    "        return None\n",
    "    space = representation_space.space \n",
    "    knowledge_framework = GeologicalKnowledgeManager().get_knowledge_framework()\n",
    "\n",
    "    share_sides = get_shared_sides_in_one_complex_surface(complex_surface, knowledge_framework, space)\n",
    "    unmatched_sides = get_unmatched_shared_sides_in_one_complex_surface(complex_surface, knowledge_framework, space)\n",
    "    sides = unmatched_sides+share_sides\n",
    "    start_node_all_sides = {}\n",
    "    sizes = []\n",
    "    for side_i in sides:\n",
    "        start_i = side_i.has_End_Points[0]\n",
    "        start_size = side_i.size[0]\n",
    "        start_node_all_sides[side_i.has_End_Points[0].name] = [start_i, start_size ]\n",
    "        if start_size not in sizes:\n",
    "            sizes.append(start_size)\n",
    "\n",
    "    num_shades = len(sizes)\n",
    "\n",
    "    shades_between_colors = get_shades_between_colors(bounding_color1, bounding_color2, num_shades)\n",
    "    \n",
    "    # Normalize values between 0 and 1\n",
    "    norm = mcolors.Normalize(vmin=min(sizes), vmax=max(sizes))\n",
    "\n",
    "    for key, values in start_node_all_sides.items():\n",
    "        # Map the value to an index in the color shade list\n",
    "        center, size = values\n",
    "        index = int(norm(size) * (num_shades - 1))\n",
    "        color_i = shades_between_colors[index] \n",
    "\n",
    "        representation_space.draw_point(data= center, marker=\"o\", \n",
    "                                        color = None, c = color_i, ax = ax  )\n",
    "        \n",
    "if mogi().ComplexSurfaceSizeSharedSidesAnomaly in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().ComplexSurfaceSizeSharedSidesAnomaly]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().ComplexSurfaceSizeSharedSidesAnomaly, draw_shared_sides_size_cplx_sur_anomaly_in_AxisAlignedCrossSection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_dip_variation_anomaly_in_AxisAlignedCrossSection(\n",
    "        anomaly,\n",
    "        representation_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        draw_normal= False,\n",
    "        color = \"r\",\n",
    "        linewidth= 5,\n",
    "        zorder = 200,\n",
    "        **kargs\n",
    "    ):\n",
    "    if setup_drawing:\n",
    "        representation_space.setup_drawing(ax)\n",
    "    else:\n",
    "        representation_space.setup_ax(ax)\n",
    "    \n",
    "    # remove any existing path effect for it to be overriden\n",
    "    if \"path_effects\" in kargs:\n",
    "        del kargs[\"path_effects\"]\n",
    "    \n",
    "    representation_space.draw(anomaly.is_Related_To[0], ax = ax, setup_drawing= False, zorder= zorder+1,\n",
    "                              path_effects=[patheffects.withStroke(foreground=color, linewidth= linewidth)],\n",
    "                              draw_normal= draw_normal, **kargs)\n",
    "    representation_space.draw(anomaly.is_Related_To[1], ax = ax, setup_drawing= False, zorder= zorder+1,\n",
    "                              path_effects=[patheffects.withStroke(foreground=color, linewidth= linewidth)],\n",
    "                              draw_normal= draw_normal, **kargs)\n",
    "    representation_space.draw_relation(*anomaly.is_Related_To, color= color, alpha= 0.8, linestyle= \"dashed\", ax = ax, setup_drawing= False,\n",
    "                                       zorder= zorder, **kargs)\n",
    "        \n",
    "if mogi().DipVariationAnomaly in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().DipVariationAnomaly]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().DipVariationAnomaly, draw_dip_variation_anomaly_in_AxisAlignedCrossSection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_internal_dip_variation_anomaly_two_parts_in_AxisAlignedCrossSection(\n",
    "        anomaly,\n",
    "        representation_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        draw_normal= False,\n",
    "        color = \"r\",\n",
    "        linewidth= 5,\n",
    "        zorder = 200,\n",
    "        **kargs\n",
    "    ):\n",
    "    if setup_drawing:\n",
    "        representation_space.setup_drawing(ax)\n",
    "    else:\n",
    "        representation_space.setup_ax(ax)\n",
    "    \n",
    "    # remove any existing path effect for it to be overriden\n",
    "    if \"path_effects\" in kargs:\n",
    "        del kargs[\"path_effects\"]\n",
    "    \n",
    "    representation_space.draw(anomaly.is_Related_To[0], ax = ax, setup_drawing= False, zorder= zorder+1,\n",
    "                              path_effects=[patheffects.withStroke(foreground=color, linewidth= linewidth)],\n",
    "                              draw_normal= draw_normal, **kargs)\n",
    "\n",
    "        \n",
    "if mogi().InternalDipVariationAnomalyTwoParts in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().InternalDipVariationAnomalyTwoParts]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().InternalDipVariationAnomalyTwoParts,\n",
    "                                                 draw_internal_dip_variation_anomaly_two_parts_in_AxisAlignedCrossSection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_internal_dip_variation_anomaly_multi_parts_in_AxisAlignedCrossSection(\n",
    "        anomaly,\n",
    "        representation_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        draw_normal= False,\n",
    "        color = \"r\",\n",
    "        linewidth= 5,\n",
    "        zorder = 200,\n",
    "        **kargs\n",
    "    ):\n",
    "    if setup_drawing:\n",
    "        representation_space.setup_drawing(ax)\n",
    "    else:\n",
    "        representation_space.setup_ax(ax)\n",
    "    \n",
    "    # remove any existing path effect for it to be overriden\n",
    "    if \"path_effects\" in kargs:\n",
    "        del kargs[\"path_effects\"]\n",
    "    \n",
    "    representation_space.draw(anomaly.is_Related_To[0], ax = ax, setup_drawing= False, zorder= zorder+1,\n",
    "                              path_effects=[patheffects.withStroke(foreground=color, linewidth= linewidth)],\n",
    "                              draw_normal= draw_normal, **kargs)\n",
    "        \n",
    "if mogi().InternalDipVariationAnomalyMultiParts in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().InternalDipVariationAnomalyMultiParts]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().InternalDipVariationAnomalyMultiParts,\n",
    "                                                 draw_internal_dip_variation_anomaly_multi_parts_in_AxisAlignedCrossSection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_discontinuous_stratigraphy_anomaly_in_AxisAlignedCrossSection(\n",
    "        anomaly,\n",
    "        representation_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        draw_normal = False,\n",
    "        color = \"r\",\n",
    "        linewidth= 5,\n",
    "        **kargs\n",
    "    ):\n",
    "    if setup_drawing:\n",
    "        representation_space.setup_drawing(ax)\n",
    "    else:\n",
    "        representation_space.setup_ax(ax)\n",
    "    \n",
    "    # remove any existing path effect for it to be overriden\n",
    "    if \"path_effects\" in kargs:\n",
    "        del kargs[\"path_effects\"]\n",
    "    \n",
    "    representation_space.draw(anomaly.is_Related_To[0], ax = ax, setup_drawing= False, zorder= 200,\n",
    "                              path_effects=[patheffects.withStroke(foreground=color, linewidth= linewidth)], \n",
    "                              draw_normal= draw_normal, **remove_kargs(\"zorder\",**kargs))\n",
    "    representation_space.draw(anomaly.is_Related_To[1], ax = ax, setup_drawing= False, zorder= 200,\n",
    "                              path_effects=[patheffects.withStroke(foreground=color, linewidth= linewidth)], \n",
    "                              draw_normal= draw_normal,  **remove_kargs(\"zorder\",**kargs))\n",
    "    representation_space.draw_relation(*anomaly.is_Related_To, color= color, alpha=0.8, linestyle= \"dashed\", ax = ax, setup_drawing= False,\n",
    "                                       zorder= 201,  **remove_kargs(\"zorder\",**kargs))\n",
    "        \n",
    "if mogi().DiscontinuousStratigraphyAnomaly in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().DiscontinuousStratigraphyAnomaly]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().DiscontinuousStratigraphyAnomaly, draw_discontinuous_stratigraphy_anomaly_in_AxisAlignedCrossSection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_polarity_anomaly_in_AxisAlignedCrossSection(\n",
    "        anomaly,\n",
    "        representation_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        draw_normal= False, \n",
    "        color = \"r\",\n",
    "        linewidth= 5,\n",
    "        zorder= 200,\n",
    "        **kargs\n",
    "    ):\n",
    "    if setup_drawing:\n",
    "        representation_space.setup_drawing(ax)\n",
    "    else:\n",
    "        representation_space.setup_ax(ax)\n",
    "    \n",
    "    # remove any existing path effect for it to be overriden\n",
    "    if \"path_effects\" in kargs:\n",
    "        del kargs[\"path_effects\"]\n",
    "    \n",
    "    representation_space.draw(anomaly.is_Related_To[0], ax = ax, setup_drawing= False, zorder= zorder+1,\n",
    "                              path_effects=[patheffects.withStroke(foreground=color, linewidth= linewidth)],  \n",
    "                              draw_normal= draw_normal, **kargs)\n",
    "    representation_space.draw(anomaly.is_Related_To[1], ax = ax, setup_drawing= False, zorder= zorder+1,\n",
    "                              path_effects=[patheffects.withStroke(foreground=color, linewidth= linewidth)],  \n",
    "                              draw_normal= draw_normal, **kargs)\n",
    "    representation_space.draw_relation(*anomaly.is_Related_To, color= color, alpha=0.8, linestyle= \"dashed\", ax = ax, setup_drawing= False,\n",
    "                                       zorder= zorder,  **kargs)\n",
    "        \n",
    "if mogi().PolarityAnomaly in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().PolarityAnomaly]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().PolarityAnomaly, draw_polarity_anomaly_in_AxisAlignedCrossSection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_explanation_anomaly_in_AxisAlignedCrossSection(\n",
    "        anomaly,\n",
    "        representation_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        color = \"r\",\n",
    "        linewidth= 5,\n",
    "        zorder= 200,\n",
    "        **kargs\n",
    "    ):\n",
    "    if setup_drawing:\n",
    "        representation_space.setup_drawing(ax)\n",
    "    else:\n",
    "        representation_space.setup_ax(ax)\n",
    "    \n",
    "    # remove any existing path effect for it to be overriden\n",
    "    if \"path_effects\" in kargs:\n",
    "        del kargs[\"path_effects\"]\n",
    "    \n",
    "    representation_space.draw(anomaly.is_Related_To_Explaining_Object[0], ax = ax, setup_drawing= False, zorder= zorder+1,\n",
    "                              path_effects=[patheffects.withStroke(foreground=color, linewidth= linewidth)],  \n",
    "                              **kargs)\n",
    "    \n",
    "    knowledge_framework = GeologicalKnowledgeManager().get_knowledge_framework()\n",
    "    explaining_rep = anomaly.is_Related_To_Explaining_Object[0].has_Representation\n",
    "    if (explaining_rep is None) or (len(explaining_rep) == 0):\n",
    "        raise MalissiaBaseError(\"Trying to draw an explanation error with an object that has no representation.\")\n",
    "    \n",
    "    explaining_rep = explaining_rep[0]\n",
    "    explained_object = anomaly.is_Related_To_Explained_Object[0]\n",
    "    if knowledge_framework.isinstance(explaining_rep, knowledge_framework().Planar_Surface):\n",
    "        # compute projection point\n",
    "        projection = representation_space.space.compute_projection_on_plane(plane= explaining_rep, object= explained_object)\n",
    "    else:\n",
    "        raise MalissiaNotImplementedYet(\"Projection on something that is not implemented\")\n",
    "                \n",
    "    # draw explanation link\n",
    "    representation_space.draw_explanation(explained_object= explained_object, projection= projection,\n",
    "                                        color= color, highlight_explained_object= True, highlight_linewidth= linewidth)\n",
    "        \n",
    "if mogi().ExplanationAnomaly in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().ExplanationAnomaly]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().ExplanationAnomaly, draw_explanation_anomaly_in_AxisAlignedCrossSection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_complex_surface_planar_anomaly(\n",
    "        anomaly,\n",
    "        representation_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        color = \"r\",\n",
    "        linewidth= 5,\n",
    "        zorder= 200,\n",
    "        draw_normal  = False, \n",
    "        **kargs\n",
    "    ):\n",
    "    if setup_drawing:\n",
    "        representation_space.setup_drawing(ax)\n",
    "    else:\n",
    "        representation_space.setup_ax(ax)\n",
    "\n",
    "    # remove any existing path effect for it to be overriden\n",
    "    if \"path_effects\" in kargs:\n",
    "        del kargs[\"path_effects\"]\n",
    "    \n",
    "    knowledge_framework = GeologicalKnowledgeManager().get_knowledge_framework()\n",
    "    for sur in anomaly.is_Related_To :\n",
    "        if isinstance(sur, knowledge_framework().Planar_Surface):\n",
    "            print('warrning {} is not of type planar_surface'.format(sur.name))\n",
    "        representation_space.draw(sur, ax = ax, setup_drawing= False, zorder= zorder+1,\n",
    "                                            path_effects=[patheffects.withStroke(foreground=color, linewidth= linewidth)],  \n",
    "                                            draw_normal= draw_normal, **kargs)\n",
    "        \n",
    "    representation_space.draw_relation(*anomaly.is_Related_To, color= color, alpha=0.8, linestyle= \"dashed\", ax = ax, setup_drawing= False,\n",
    "                                       zorder= zorder,  **kargs)\n",
    "        \n",
    "if mogi().ComplexSurfacePlanarAnomaly in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().ComplexSurfacePlanarAnomaly]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().ComplexSurfacePlanarAnomaly, draw_complex_surface_planar_anomaly)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_complex_surface_nb_neighbors_anomaly(\n",
    "        anomaly,\n",
    "        representation_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        color = \"r\",\n",
    "        linewidth= 5,\n",
    "        zorder= 200,\n",
    "        draw_normal  = False, \n",
    "        **kargs\n",
    "    ):\n",
    "    \n",
    "    \n",
    "    if setup_drawing:\n",
    "        representation_space.setup_drawing(ax)\n",
    "    else:\n",
    "        representation_space.setup_ax(ax)\n",
    "\n",
    "    # remove any existing path effect for it to be overriden\n",
    "    if \"path_effects\" in kargs:\n",
    "        del kargs[\"path_effects\"]\n",
    "    \n",
    "    knowledge_framework = GeologicalKnowledgeManager().get_knowledge_framework()\n",
    "\n",
    "    if knowledge_framework().Complex_Surface in anomaly.is_Related_To[0].is_a:\n",
    "        \n",
    "        representation_space.draw_multiple_planes(anomaly.is_Related_To[0].has_Part, \n",
    "                                                  path_effects=[patheffects.withStroke(foreground= color, linewidth= linewidth)],\n",
    "                              ax = ax, setup_drawing= False, zorder= zorder,\n",
    "                              draw_normal= draw_normal, **kargs)\n",
    "            \n",
    "    \n",
    "        \n",
    "if mogi().ComplexSurfaceNeighborNumberAnomaly in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().ComplexSurfaceNeighborNumberAnomaly]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().ComplexSurfaceNeighborNumberAnomaly, draw_complex_surface_nb_neighbors_anomaly)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_shared_sides_not_parallel_anomaly_in_AxisAlignedCrossSection(\n",
    "        anomaly,\n",
    "        representation_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        color = \"red\", \n",
    "        **kargs\n",
    "    ):\n",
    "    if setup_drawing:\n",
    "        representation_space.setup_drawing(ax)\n",
    "    else:\n",
    "        representation_space.setup_ax(ax)\n",
    "    if len(anomaly.is_Related_To) < 1 :\n",
    "        print('Warning: anomaly {} is not related to any complex_surface'.format(anomaly.name))\n",
    "        return None\n",
    "    \n",
    "    complex_surface = anomaly.is_Related_To[0]\n",
    "    if len(complex_surface.has_Part) < 2:\n",
    "        print('Warning: complex_surface {} related to the anomaly {} deos not have enough parts '.format(complex_surface.name, anomaly.name))\n",
    "        return None\n",
    "    space = representation_space.space \n",
    "    knowledge_framework = GeologicalKnowledgeManager().get_knowledge_framework()\n",
    "\n",
    "    share_sides = get_shared_sides_in_one_complex_surface(complex_surface, knowledge_framework, space)\n",
    "    unmatched_sides = get_unmatched_shared_sides_in_one_complex_surface(complex_surface, knowledge_framework, space)\n",
    "    sides = unmatched_sides+share_sides\n",
    "    start_node_all_sides = {}\n",
    "    sizes = []\n",
    "    for side_i in sides:\n",
    "        start_i = side_i.has_End_Points[0]\n",
    "        representation_space.draw_point(data= start_i, marker=\"o\", \n",
    "                                        color = color, ax = ax  )\n",
    "        \n",
    "if mogi().SharedSideNotParallelAnomaly in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[mogi().SharedSideNotParallelAnomaly]\n",
    "AxisAlignedCrossSection.register_drawing_method(mogi().SharedSideNotParallelAnomaly, draw_shared_sides_not_parallel_anomaly_in_AxisAlignedCrossSection)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interpretation Workflow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The interpretation process in itself is run in a **GeologicalInterpretationProcess** and follow a very simple and generic algorithm.<br>\n",
    "This algorithm implements a Deming wheel process of continual improvement:\n",
    "1. Plan:\n",
    "    1. Select a situation\n",
    "    2. Select an action\n",
    "2. Do: Implement the action (e.g., CreateInterpretationElement)\n",
    "    1. List features\n",
    "    2. Identify possible explanations\n",
    "    3. Rank/chose explanations\n",
    "    4. Instanciate individuals\n",
    "    5. Infer and set parameters\n",
    "3. Check: Evaluate consistency\n",
    "    1. Evaluate internal consistency\n",
    "    2. Evaluate relational likelihood\n",
    "    3. Evaluate feature explanation\n",
    "4. Act: Generate anomalies and report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "import random\n",
    "from enum import Enum, Flag, auto\n",
    "class TerminationFlag(Flag):\n",
    "    \"\"\"Defines flags for specifying why the `GeologicalInterpretationProcess` stoped\n",
    "    \n",
    "    NOTSTARTED: it has not been started yet\n",
    "    PROCESSING: it is currently processing\n",
    "    USER: was terminated by user\n",
    "    MAX_ITER: maximum iteration number reached\n",
    "    N_ITER: maximum number of iterations for this run reached\n",
    "    \"\"\"\n",
    "    NOTSTARTED = 0\n",
    "    PROCESSING = auto()\n",
    "    USER = auto()\n",
    "    MAX_ITER = auto()\n",
    "    N_ITER = auto()\n",
    "   \n",
    "class AbortIterationFlag(Flag):\n",
    "   \"\"\"Flags to declare reasons for aborting interpretation iteration\n",
    "   \n",
    "   UNDEFINED_MOVE: the key for the move is not defined or the action is not implemented\n",
    "   NO_POSSIBLE_EXPLANATION: the situation has no possible explanation\n",
    "   \"\"\"\n",
    "   UNDEFINED_MOVE = auto()\n",
    "   NO_POSSIBLE_EXPLANATION = auto()\n",
    "   UNDEFINED_CONSTRUCTOR= auto()\n",
    "   \n",
    "class InterpretationIteration(object):\n",
    "   \"\"\"Class to handle informations about each iteration\n",
    "   \n",
    "   Iterations are stored in the history of the interpretation process.\n",
    "   \n",
    "   Attributes:\n",
    "   - epoch: the id of the corresponding epoch (iteration)\n",
    "   - situation: the situation selected at this iteration\n",
    "   - move: the move to be implemented during this iteration\n",
    "   - result: the result of the given iteration\"\"\"\n",
    "   \n",
    "   def __init__(self, epoch):\n",
    "      self.epoch= epoch\n",
    "      self.situation= None\n",
    "      self.interpretation_move = None\n",
    "      \n",
    "   def __str__(self):\n",
    "        return \"\\n\".join([str(k)+\": \"+str(val) for k, val in self.__dict__.items()])\n",
    "\n",
    "def select_user_unexplained_observation(process):\n",
    "   \"\"\"user selects a single feature to be explained\"\"\"\n",
    "   observations = process.dataset.get_unexplained_observations()\n",
    "   message = \"; \".join([\"{}: {}\".format(i,obs_i.name) for i, obs_i in enumerate(observations)])\n",
    "   selected_feature_index = int(input(message))\n",
    "   selected_feature = observations[selected_feature_index]\n",
    "   process.iteration.situation = InterpretationSituation( features= [selected_feature], process= process)\n",
    "   \n",
    "def select_user_unexplained_observations(process):\n",
    "   \"\"\"user selects several observations to be explained\"\"\"\n",
    "   observations = process.dataset.get_unexplained_observations()\n",
    "   message = \"; \".join([\"{}: {}\".format(i,obs_i.name) for i, obs_i in enumerate(observations)])\n",
    "   number_of_observations = int(input('enter the desired number of observations to be selected'))\n",
    "   if number_of_observations > len(observations):\n",
    "      raise MalissiaBaseError('the chosen number of observations is greater than the number of existing observations')\n",
    "   features = [] \n",
    "   for nb in range(number_of_observations):\n",
    "      selected_feature_index = int(input(message))\n",
    "      selected_feature = observations[selected_feature_index]\n",
    "      features.append(selected_feature)\n",
    "   process.iteration.situation = InterpretationSituation( features= features, process= process)\n",
    "\n",
    "def select_single_random_unexplained_observation(process):\n",
    "   \"\"\"randomly selects a single feature to be explained\"\"\"\n",
    "   observations = process.dataset.get_unexplained_observations()\n",
    "   selected_feature = random.choice(observations) if len(observations) > 0 else []\n",
    "   process.iteration.situation = InterpretationSituation( features= [selected_feature], process= process)\n",
    "   \n",
    "def select_random_unexplained_observations(process, n_min= 2, n_max= 6):\n",
    "   \"\"\"randomly selects a given number of features to be explained\"\"\"\n",
    "   observations = process.dataset.get_unexplained_observations()\n",
    "   if len(observations) == 0:\n",
    "      return []\n",
    "   \n",
    "   n_max = min(n_max, len(observations))\n",
    "   n_min = min(n_min, len(observations))\n",
    "   n = random.randint(n_min,n_max)\n",
    "   selected_feature = random.sample(observations, k= n)\n",
    "   process.iteration.situation = InterpretationSituation( features= selected_feature, process= process)\n",
    "\n",
    "def select_user_unexplained_feature(process):\n",
    "   \"\"\"user selects a single feature to be explained\"\"\"\n",
    "   features = process.get_unexplained_features()\n",
    "   message = \"; \".join([\"{}: {}\".format(i,obs_i.name) for i, obs_i in enumerate(features)])\n",
    "   selected_feature_index = int(input(message))\n",
    "   selected_feature = features[selected_feature_index]\n",
    "   process.iteration.situation = InterpretationSituation( features= [selected_feature], process= process)\n",
    "\n",
    "def select_user_unexplained_features(process):\n",
    "   \"\"\"user selects a single feature to be explained\"\"\"\n",
    "   features = process.get_unexplained_features()\n",
    "   message = \"; \".join([\"{}: {}\".format(i,obs_i.name) for i, obs_i in enumerate(features)])\n",
    "   number_of_features = int(input('enter the desired number of features to be selected'))\n",
    "   if number_of_features > len(features):\n",
    "      raise MalissiaBaseError('the chosen number of features is greater than the number of existing unexplained_features')\n",
    "   features_to_be_returned = [] \n",
    "   for nb in range(number_of_features):\n",
    "      selected_feature_index = int(input(message))\n",
    "      selected_feature = features[selected_feature_index]\n",
    "      features_to_be_returned.append(selected_feature)\n",
    "   process.iteration.situation = InterpretationSituation( features= features_to_be_returned, process= process)\n",
    "\n",
    "def select_single_random_unexplained_feature(process):\n",
    "   \"\"\"randomly selects a single feature to be explained\"\"\"\n",
    "   process.iteration.situation = select_random_unexplained_features(process= process, n_max= 1)\n",
    "   \n",
    "def select_random_unexplained_features(process, n_min= 2, n_max= 6):\n",
    "   \"\"\"randomly selects a given number of features to be explained\"\"\"\n",
    "   features = process.get_unexplained_features()\n",
    "   if len(features) == 0:\n",
    "      return []\n",
    "   \n",
    "   n_max = min(n_max, len(features))\n",
    "   n_min = min(n_min, len(features))\n",
    "   n = random.randint(n_min,n_max)\n",
    "   selected_feature = random.sample(features, k= n)\n",
    "   process.iteration.situation = InterpretationSituation( features= selected_feature, process= process)\n",
    "\n",
    "class GeologicalInterpretationProcess(object):\n",
    "   \"\"\"GeologicalInterpretationProcess implements the core process of a geological intepretation.\n",
    "    \n",
    "    It connects all the required elements and resulting artefacts relatively to a given interpretation sequence:\n",
    "     - knowledge_framework: a GeologicalKnowledgeFramework\n",
    "     - dataset: a GeologicalDataSet that interfaces all the available data\n",
    "     - representation_space: a `RepresentationSpace` defining the study zone\n",
    "     - strategies: a dict that associates algorithm stages with preferred options\"\"\"\n",
    "   \n",
    "   default_strategies = {\n",
    "      \"SituationSelection\": select_random_unexplained_features\n",
    "   }\n",
    "     \n",
    "   def __init__(self,\n",
    "                dataset: GeologicalDataset,\n",
    "                representation_space: RepresentationSpace = None,\n",
    "                knowledge_framework= None,\n",
    "                strategies = {}):\n",
    "      \"\"\"Creates a GeologicalInterpretationProcess\n",
    "        \n",
    "      ---------------------------\n",
    "      Parameters:\n",
    "       - dataset (GeologicalDataset): a dataset to be explained by this interpretor\n",
    "       - representation_space (RepresentationSpace): the representation space that must be explainined by the interpretation.\n",
    "       If None (default), the physical space of the dataset is used instead.\n",
    "       - knowledge_framework: a GeologicalKnowledgeFramework that defines the concepts used for this interpretation.\n",
    "         If None is given, the the default knowledge framework is used (`GeologicalKnowledgeManager().get_knowledge_framework()`)\n",
    "       - strategies: a dict that associates algorithm stages with preferred options\n",
    "      \"\"\"\n",
    "      self.dataset = dataset\n",
    "      self.interpreted_objects = list()\n",
    "      self.anomalies = list()\n",
    "      self.representation_space = representation_space if representation_space is not None else self.dataset.physical_space\n",
    "      self.knowledge_framework= GeologicalKnowledgeManager().get_knowledge_framework() if knowledge_framework is None else knowledge_framework\n",
    "      \n",
    "      self.strategies = {**GeologicalInterpretationProcess.default_strategies, **strategies}\n",
    "      \n",
    "      self.update_status(init= True)\n",
    "         \n",
    "      self.interpretation_moves ={\n",
    "         \"NewInterpretation\": self.apply_new_interpretation,\n",
    "         \"UpdateInterpretation\": self.apply_update_interpretation,\n",
    "         \"RemoveInterpretation\": self.apply_remove_interpretation\n",
    "      }\n",
    "      \n",
    "   def __init_status(self, init):\n",
    "      \"\"\"creates the status on first run or reset\n",
    "      \n",
    "      This is setting the:\n",
    "      - status: to store information on the interpretation current progress\n",
    "      - report: to pass on information to the next iteration\n",
    "        - abort_iteration: signal to abort the iteration\n",
    "        - abort_reason: a keyword to explain the reason for aborting\n",
    "      - history: to store the past iterations \n",
    "      \"\"\"\n",
    "      if not hasattr(self, \"status\"):\n",
    "         self.status = {}\n",
    "         init = True\n",
    "      if init:\n",
    "         self.status[\"epoch\"] = None # index of the current iteration\n",
    "         self.iteration = None\n",
    "         self.report = {}\n",
    "         self.history = []\n",
    "         self.interpreted_objects = []\n",
    "         self.anomalies = []\n",
    "      \n",
    "   def update_status(self, init= False):\n",
    "      \"\"\"Performs status update operations\n",
    "      \n",
    "      If the status is not set yet, this method will also create it and initialise it.\n",
    "      \n",
    "      Parameters:\n",
    "      - init (Bool): if True, the status will be reset to initial values. Default is False.\"\"\"\n",
    "      self.__init_status(init)\n",
    "            \n",
    "      # updating indicators\n",
    "      self.status[\"coverage\"] = self.evaluate_coverage() # ratio of representation space covered by an explanation\n",
    "      self.status[\"data_explanation_ratio\"] = self.evaluate_data() # ratio of explained observations\n",
    "      self.status[\"anomaly_explanation_ratio\"] =  self.evaluate_anomalies() # ratio of explained observations\n",
    "      \n",
    "      # setting termination status\n",
    "      if init:\n",
    "         self.status[\"termination_criterion\"] = TerminationFlag.NOTSTARTED # gives explanation about why it terminated\n",
    "      else:\n",
    "         self.status[\"termination_criterion\"] = TerminationFlag.PROCESSING # gives explanation about why it terminated\n",
    "      \n",
    "   def register_interpreted_object(self, object, **kargs):\n",
    "      \"\"\"Registers an interpreted object\"\"\"\n",
    "      self.interpreted_objects.append(object)\n",
    "      self.representation_space.attach_interpreted_object(object, **kargs)\n",
    "      \n",
    "   \n",
    "   def get_unexplained_features(self):\n",
    "        \"\"\"Accessor filtering out explained observation and interpreted_objects\n",
    "        \"\"\"\n",
    "        unexplained_observations = [obs_i for obs_i in self.dataset.get_observations()\n",
    "                                          if (obs_i.is_Explained_By is not None) and len(obs_i.is_Explained_By) == 0]\n",
    "        unexplained_interpreted_objects = [obj_i for obj_i in self.interpreted_objects\n",
    "                                          if (obj_i.is_Explained_By is not None) and (len(obj_i.is_Explained_By) == 0)]\n",
    "        unexplained_anomalies = [obj_i for obj_i in self.anomalies\n",
    "                                          if (obj_i.is_Explained_By is not None) and (len(obj_i.is_Explained_By) == 0)]\n",
    "        return unexplained_observations + unexplained_interpreted_objects + unexplained_anomalies\n",
    "     \n",
    "   def evaluate_coverage(self):\n",
    "      \"\"\"Evaluates the amount of physical space that is explained\n",
    "      \n",
    "      Returns:\n",
    "      - a float between 0 and 1, representing the ratio of covered space\"\"\"\n",
    "      return self.representation_space.evaluate_coverage(self.interpreted_objects)\n",
    "      \n",
    "   def evaluate_data(self):\n",
    "      \"\"\"Evaluates the amount of data that is explained\n",
    "      \n",
    "      Returns:\n",
    "      - a float between 0 and 1, representing the ratio of explained data\"\"\"\n",
    "      return 0\n",
    "   \n",
    "   def evaluate_anomalies(self):\n",
    "      \"\"\"Evaluates the amount of raised anomalies that are now explained\n",
    "      \n",
    "      Returns:\n",
    "      - a float between 0 and 1, representing the ratio of explained anomalies\"\"\"\n",
    "      return 0\n",
    "   \n",
    "   def __str__(self):\n",
    "      \"\"\"Return a report describing the interpretation process\"\"\"\n",
    "      desc = [\"Geological Interpretation Process:\"]\n",
    "      if self.dataset is None:\n",
    "         desc+= [\"|- Dataset: None\"]\n",
    "      else:\n",
    "         desc+= [\"|- Dataset: \"+\"\\n| |\".join(self.dataset.__str__().split(\"\\n\"))]\n",
    "         \n",
    "      if self.knowledge_framework is None:\n",
    "         desc+= [\"|- Geological Knowledge Framework: None\"]\n",
    "      else:\n",
    "         desc+= [\"|- \"+\"\\n| |\".join(self.knowledge_framework.__str__().split(\"\\n\"))]\n",
    "         \n",
    "      if self.representation_space is None:\n",
    "         desc+= [\"|- No representation space defined, this is an abstract interpretation only.\"]\n",
    "      else:\n",
    "         desc+= [\"|- \"+\"\\n| |\".join(self.representation_space.__str__().split(\"\\n\"))]\n",
    "         \n",
    "      return \"\\n\".join(desc)\n",
    "   \n",
    "   def run(self, max_iter= None, n_iter= None):\n",
    "      \"\"\"Runs the iterative interpretation process\n",
    "      \n",
    "      Parameters:\n",
    "      - max_iter (int): if set, it specifies the maximum number of iterations to run before terminating.\n",
    "      - n_iter (int): if set, specifies to run for another \"n_iter\" number of iteration.\n",
    "      Compared to max_iter, this is ignoring the number of already passed iterations.\n",
    "      Iteration (epoch) are numbered starting at 0, this way the counter also represents the number of passed iterations.\n",
    "      \"\"\"\n",
    "      \n",
    "      # run the iterative process as long as a termination criterion is not reached\n",
    "      \n",
    "      #first update the status to make sure it is up to date, and reset the termination criteria\n",
    "      self.update_status()\n",
    "      \n",
    "      # new epoch increments the iteration count and check termination\n",
    "      try:\n",
    "         self.status[\"current_run_starting_epoch\"] = self.status[\"epoch\"]\n",
    "         while self.new_epoch(max_iter = max_iter, n_iter = n_iter):\n",
    "            \n",
    "            # 1. Plan: Select a situation & an action\n",
    "            self.plan()\n",
    "            \n",
    "            # 2. Do: execute the specified action\n",
    "            if not self.report[\"abort_iteration\"]:\n",
    "               self.do()\n",
    "            \n",
    "            # 3. Check\n",
    "            # -----------------------------\n",
    "            #  3.1 Evaluate internal consistency\n",
    "            #  3.2 Evaluate relational likelihood\n",
    "            #  3.3 Evaluate feature explanation\n",
    "            if not self.report[\"abort_iteration\"]:\n",
    "               self.check()\n",
    "            \n",
    "            # 4. Act\n",
    "            # -----------------------------\n",
    "            # 4.1 Generate anomalies and report\n",
    "            # 4.2 update status\n",
    "            if not self.report[\"abort_iteration\"]:\n",
    "               self.act()\n",
    "            \n",
    "      except KeyboardInterrupt:\n",
    "         self.status[\"termination_criterion\"] = TerminationFlag.USER\n",
    "         \n",
    "      return self.status[\"termination_criterion\"]\n",
    "         \n",
    "   def new_epoch(self, max_iter= None, n_iter= None):\n",
    "      \"\"\"Starts a new epoch (iteration) unless termination criteria were reached\n",
    "      \n",
    "      Returns:\n",
    "      - True if the new epoch should start, False if iterations should stop\n",
    "      - max_iter (int): if set, it specifies the maximum number of iterations to run before terminating\"\"\"\n",
    "      \n",
    "      # Increment epoch number\n",
    "      self.increment_epoch()\n",
    "      \n",
    "      if (max_iter is not None) and (self.status[\"epoch\"] >= max_iter):\n",
    "         self.status[\"termination_criterion\"] = TerminationFlag.MAX_ITER\n",
    "         return False\n",
    "      \n",
    "      if (n_iter is not None) and (self.status[\"epoch\"] - self.status[\"current_run_starting_epoch\"] >= n_iter):\n",
    "         self.status[\"termination_criterion\"] = TerminationFlag.N_ITER\n",
    "         return False\n",
    "      \n",
    "      # Create a new iteration\n",
    "      self.iteration = InterpretationIteration(epoch= self.status[\"epoch\"])\n",
    "            \n",
    "      self.report[\"abort_iteration\"] = False\n",
    "      self.report[\"abort_reason\"] = None\n",
    "      \n",
    "      return True\n",
    "      \n",
    "   def increment_epoch(self):\n",
    "      \"\"\"Initialize or increment the epoch count\"\"\"\n",
    "      if self.status[\"epoch\"] is None:\n",
    "         self.status[\"epoch\"] = 0\n",
    "         self.status[\"current_run_starting_epoch\"] = self.status[\"epoch\"] \n",
    "      else:\n",
    "         self.status[\"epoch\"] += 1\n",
    "      \n",
    "   def select_strategy(self, key):\n",
    "      \"\"\"Select a the implementation to be used based on strategy\"\"\"\n",
    "      if key not in self.strategies:\n",
    "         raise MalissiaBaseError(\"The task has no defined strategy: \" + key)\n",
    "      strat = self.strategies[key]\n",
    "      if isinstance(strat,list):\n",
    "         strat = random.choice(strat)\n",
    "      return strat\n",
    "   \n",
    "   def plan(self, move_key = None, random_move = False ):\n",
    "      \"\"\"Perform the Plan part of the algorithm\n",
    "      \n",
    "      1. Select a situation to be explained\n",
    "      2. Select a Type of move to be performed in the interpretation process\"\"\"\n",
    "      \n",
    "      # Select a Situation\n",
    "      strategy_for_selecting_situation = self.select_strategy(\"SituationSelection\")\n",
    "      strategy_for_selecting_situation(self)\n",
    "      \n",
    "      # Select interpretation move (see self.interpretation_moves)\n",
    "      self.select_interpretation_move(key= move_key, random= random_move)\n",
    "      \n",
    "   def select_interpretation_move(self, key = None, random = False):\n",
    "      \"\"\"Select the type of interpretation action to be taken.\n",
    "      \n",
    "      Parameters:\n",
    "      - key: the key corresponding to the chosen action, see `interpretation_moves`.\n",
    "      This is to be used only for forcing the choice. Default, None.\n",
    "      - random: if True, will be chosen among the available options (default: False).\n",
    "      \"\"\"\n",
    "      \n",
    "      # random of user choice\n",
    "      if key is None and random:\n",
    "         key = random.choice( self.interpretation_moves.keys() )\n",
    "         \n",
    "      if key is not None:\n",
    "         self.iteration.interpretation_move = key\n",
    "      else:\n",
    "         # default move is creating an new interpretation\n",
    "         # Todo: this could be defined by a strategy\n",
    "         self.iteration.interpretation_move = \"NewInterpretation\"\n",
    "         # when applicable do others\n",
    "         # when existing features show anomalies, try and update\n",
    "         #if exisitng explanation anomalies:\n",
    "         #   if keep_trying:\n",
    "         #     self.iteration.interpretation_move = \"UpdateInterpretation\"\n",
    "         #   else:\n",
    "         #      self.iteration.interpretation_move = \"RemoveInterpretation\"\n",
    "      return self.interpretation_moves[self.iteration.interpretation_move]\n",
    "   \n",
    "   def do(self, **kargs):\n",
    "      \"\"\"Applies the selected move in the current context\"\"\"\n",
    "      if self.iteration.interpretation_move not in self.interpretation_moves:\n",
    "         print(\"The move {} is not implemented.\".format(self.iteration.interpretation_move))\n",
    "         self.report[\"abort_iteration\"] = True\n",
    "         self.report[\"abort_reason\"] = AbortIterationFlag.UNDEFINED_MOVE\n",
    "         return\n",
    "      \n",
    "      move_method = self.interpretation_moves[self.iteration.interpretation_move]\n",
    "      move_method(**kargs)\n",
    "      \n",
    "      if (\"sync_reasoner\" in kargs) and (kargs[\"sync_reasoner\"]):\n",
    "         self.knowledge_framework.sync_reasoner()\n",
    "   \n",
    "   def apply_new_interpretation(self, random_choice= False, force_explanation= None, force_constructor= None, debug= False):\n",
    "      \"\"\"Implements the creation of a new interpretation object\"\"\"\n",
    "      \n",
    "      situation = self.iteration.situation\n",
    "      if situation is None:\n",
    "         raise MalissiaBaseError(\"Something needs to be selected for interpretation. Here the situtation is None.\")\n",
    "      \n",
    "      if len(situation.features) == 0:\n",
    "         raise MalissiaBaseError(\"Not implemented yet: trying to interprete without selected features.\")\n",
    "      \n",
    "      # if force explanation, use it, else try and find possible explanations\n",
    "      if force_explanation is not None:\n",
    "         situation.candidate_explanation_class = force_explanation\n",
    "      else:\n",
    "         # get a list of possibly explaining concepts for the features to be explained\n",
    "         possible_explanations = [concept\n",
    "                              for feature_i in situation.features\n",
    "                              for concept in self.knowledge_framework.get_possible_interpretations_of(feature_i)]\n",
    "         \n",
    "         # check if there are candidate explanations\n",
    "         if len(possible_explanations) == 0:\n",
    "            self.report[\"abort_iteration\"] = True\n",
    "            self.report[\"abort_reason\"] = AbortIterationFlag.NO_POSSIBLE_EXPLANATION\n",
    "            return\n",
    "         \n",
    "         # select a possible explanation\n",
    "         if random_choice:\n",
    "            # pick an explaining concept\n",
    "            situation.candidate_explanation_class = random.choice(possible_explanations)\n",
    "         else:\n",
    "            ## todo : sort existing concepts by preference\n",
    "            #possible_explanations = possible_explanations\n",
    "            situation.candidate_explanation_class = possible_explanations[0]\n",
    "            \n",
    "      # check for existing instances of this concept in the selected context   \n",
    "      if len(situation.context) > 0:\n",
    "         existing_explaining_instances = [context_object\n",
    "                              for context_object in situation.context\n",
    "                              if self.knowledge_framework.isinstance(context_object, situation.candidate_explanation_class)]\n",
    "      else:\n",
    "         existing_explaining_instances = []\n",
    "         \n",
    "      # if applicable use existing explaining instance else create a new one\n",
    "      if len(existing_explaining_instances) > 0:\n",
    "         situation.existing_explaining_object = True\n",
    "         situation.explaining_object = random.choice(existing_explaining_instances)\n",
    "      else:\n",
    "         constructor = force_constructor if force_constructor is not None else self.knowledge_framework.select_object_constructor(\n",
    "                              situation.candidate_explanation_class,\n",
    "                              interpretation_situation = situation,\n",
    "                              interpretation_status = self.status,\n",
    "                              random_choice = random_choice,\n",
    "                              debug= debug\n",
    "                              )\n",
    "         \n",
    "         if constructor is None:\n",
    "            self.report[\"abort_iteration\"] = True\n",
    "            self.report[\"abort_reason\"] = AbortIterationFlag.UNDEFINED_CONSTRUCTOR\n",
    "            return\n",
    "         else:\n",
    "            situation.explaining_object = constructor(\n",
    "                                                   interpretation_situation = situation,\n",
    "                                                   interpretation_status = self.status\n",
    "                                                   )\n",
    "            self.register_interpreted_object(situation.explaining_object)\n",
    "   \n",
    "   def apply_update_interpretation(self):\n",
    "      \"\"\"Implements the update of an existing interpretation object\"\"\"\n",
    "      pass\n",
    "   \n",
    "   def apply_remove_interpretation(self):\n",
    "      \"\"\"Implements the removal of an existing interpretation object\"\"\"\n",
    "      self.knowledge_framework.remove_all_instances(self.iteration.situation.features)\n",
    "       \n",
    "   \n",
    "   def check(self, **karg):\n",
    "      \"\"\"Check the consistency of the interpretation step\"\"\"\n",
    "      \n",
    "      candidate_object = self.iteration.situation.explaining_object\n",
    "      if candidate_object is None:\n",
    "         raise MalissiaBaseError(\"resulting object is None.\\nIteration state: {}\".format(self.iteration))\n",
    "      \n",
    "      # check internal consistency of the interpreted object\n",
    "      internal_anomaly = self.knowledge_framework.evaluate_internal_consistency(candidate_object, physical_space= self.representation_space)\n",
    "      self.iteration.situation.anomalies += internal_anomaly\n",
    "      self.anomalies += internal_anomaly\n",
    "      \n",
    "      # check the consistency between the interpreted object and what it is explaining\n",
    "      explanation_anomaly = self.knowledge_framework.evaluate_explanation_consistency(candidate_object, physical_space= self.representation_space)\n",
    "      self.iteration.situation.anomalies += explanation_anomaly\n",
    "      self.anomalies += explanation_anomaly\n",
    "      \n",
    "      # check the consistency between the different interpreted objects\n",
    "      \n",
    "   def act(self, ** kargs):\n",
    "      \"\"\"Finalise an iteration\"\"\"   \n",
    "      self.update_status()\n",
    "      \n",
    "      # store finalised iteration in history\n",
    "      self.history += [self.iteration]\n",
    "      \n",
    "   def show(self, drawing_space, **kargs):\n",
    "      drawing_space.draw(self, **kargs)\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_interpretation_process_in_AxisAlignedCrossSection(\n",
    "        process: GeologicalInterpretationProcess,\n",
    "        drawing_space,\n",
    "        ax= None,\n",
    "        setup_drawing= True,\n",
    "        draw_dataset= True,\n",
    "        draw_situation= True,\n",
    "        draw_interpretation= True,\n",
    "        draw_explanation= False,\n",
    "        draw_anomalies= False,\n",
    "        **kargs\n",
    "    ):\n",
    "    if setup_drawing:\n",
    "        drawing_space.setup_drawing(ax)\n",
    "    else:\n",
    "        drawing_space.setup_ax(ax)\n",
    "        \n",
    "    # draw dataset\n",
    "    if draw_dataset:\n",
    "        drawing_space.draw(process.dataset, setup_drawing= False, **kargs)\n",
    "    \n",
    "    # draw created objects\n",
    "    if draw_interpretation:\n",
    "        for feature_i in process.interpreted_objects:\n",
    "            drawing_space.draw(feature_i, color= \"gold\", setup_drawing= False, zorder= 40, draw_explanation= draw_explanation, **kargs)\n",
    "            \n",
    "    # draw anomalies\n",
    "    if draw_anomalies:\n",
    "        for anomaly in process.anomalies:\n",
    "            drawing_space.draw(anomaly, color= \"pink\", setup_drawing= False, zorder= 50, **kargs)\n",
    "        \n",
    "    # draw situation\n",
    "    if draw_situation:\n",
    "        if process.iteration is not None and process.iteration.situation is not None:\n",
    "            drawing_space.draw(process.iteration.situation, setup_drawing= False, **kargs)\n",
    "        \n",
    "\n",
    "if GeologicalInterpretationProcess in AxisAlignedCrossSection.registered_drawing_methods:\n",
    "    del AxisAlignedCrossSection.registered_drawing_methods[GeologicalInterpretationProcess]\n",
    "AxisAlignedCrossSection.register_drawing_method(GeologicalInterpretationProcess, draw_interpretation_process_in_AxisAlignedCrossSection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# General demo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "GeologicalKnowledgeManager().load_knowledge_framework()\n",
    "mogi = GeologicalKnowledgeManager().get_knowledge_framework()\n",
    "mogi.remove_all_instances()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dataset = load_dataset_from_csv(\"../inputs/sparse_data.csv\", sep=\";\", index= \"id\", coordinate_labels=[\"x\",\"y\",\"z\"], labels={\"ID\":\"id\", \"dip\": \"dip\", \"strike\":\"dip_dir\",\"name\":\"observed_object\"})\n",
    "#sp = PhysicalRepresentationSpace(coordinate_labels=[\"x\",\"y\",\"z\"])\n",
    "#sp.extension = [[0,230], [-40,-40], [-70,0]]\n",
    "#section1 = AxisAlignedCrossSection(sp, )\n",
    "section = AxisAlignedCrossSection(dataset.physical_space, )\n",
    "section.draw(dataset)\n",
    "#dataset.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### manually\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize Interpretation Process\n",
    "gip = GeologicalInterpretationProcess(dataset)\n",
    "sp = gip.representation_space\n",
    "gip.update_status()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iteration 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 0\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plan the iteration\n",
    "gip.new_epoch()\n",
    "print(\"Iteration:\",gip.iteration.epoch)\n",
    "gip.iteration.situation = InterpretationSituation(\n",
    "    features= [mogi().D4,mogi().D5], process= gip\n",
    ")\n",
    "gip.iteration.interpretation_move = \"NewInterpretation\"\n",
    "gip.show(section)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 0\n",
      "situation: Features: mogi.D4, mogi.D5\n",
      "Context: None\n",
      "Candidate explaining class: mogi.Stratigraphic_Part\n",
      "Explaining Object: mogi.stratigraphic_part1\n",
      "Anomalies: mogi.dippingstratigraphyanomaly1\n",
      "interpretation_move: NewInterpretation\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Do :  apply the move\n",
    "gip.do()\n",
    "gip.check()\n",
    "gip.act()\n",
    "gip.show(section)\n",
    "print(gip.iteration)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iteration 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 1\n",
      "epoch: 1\n",
      "situation: Features: mogi.D3\n",
      "Context: None\n",
      "Candidate explaining class: mogi.Stratigraphic_Part\n",
      "Explaining Object: mogi.stratigraphic_part2\n",
      "Anomalies: mogi.dippingstratigraphyanomaly2\n",
      "interpretation_move: NewInterpretation\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plan the iteration\n",
    "gip.new_epoch()\n",
    "print(\"Iteration:\",gip.iteration.epoch)\n",
    "gip.iteration.situation = InterpretationSituation(\n",
    "    features= [mogi().D3], process= gip\n",
    ")\n",
    "gip.iteration.interpretation_move = \"NewInterpretation\"\n",
    "gip.do()\n",
    "gip.check()\n",
    "gip.act()\n",
    "gip.show(section)\n",
    "print(gip.iteration)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iteration 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 2\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plan the iteration\n",
    "gip.new_epoch()\n",
    "print(\"Iteration:\",gip.iteration.epoch)\n",
    "gip.iteration.situation = InterpretationSituation(\n",
    "    features= [gip.history[0].situation.explaining_object, gip.history[1].situation.explaining_object], process= gip\n",
    ")\n",
    "gip.iteration.interpretation_move = \"NewInterpretation\"\n",
    "gip.show(section)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sides [mogi.shared_side_nb_1]\n",
      "sides [mogi.shared_side_nb_1]\n",
      "epoch: 2\n",
      "situation: Features: mogi.stratigraphic_part1, mogi.stratigraphic_part2\n",
      "Context: None\n",
      "Candidate explaining class: mogi.Stratigraphic_Part\n",
      "Explaining Object: mogi.stratigraphic_part3\n",
      "Anomalies: mogi.internaldipvariationanomalytwoparts1\n",
      "interpretation_move: NewInterpretation\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "gip.do()\n",
    "gip.check()\n",
    "gip.act()\n",
    "gip.show(section)\n",
    "print(gip.iteration)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Interpreted Objects:\n",
      "- stratigraphic_part1\n",
      "- stratigraphic_part2\n",
      "- stratigraphic_part3\n",
      "\n",
      "Anomalies:\n",
      "- dippingstratigraphyanomaly1\n",
      "- dippingstratigraphyanomaly2\n",
      "- internaldipvariationanomalytwoparts1\n"
     ]
    }
   ],
   "source": [
    "print(\"Interpreted Objects:\\n- \"+\"\\n- \".join([obj_i.name for obj_i in gip.interpreted_objects]))\n",
    "print(\"\\nAnomalies:\\n- \"+\"\\n- \".join([obj_i.name for obj_i in gip.anomalies]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iteration 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 3\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plan the iteration\n",
    "gip.new_epoch()\n",
    "print(\"Iteration:\",gip.iteration.epoch)\n",
    "gip.iteration.situation = InterpretationSituation(\n",
    "    features= [gip.history[-1].situation.anomalies[0], gip.history[-1].situation.explaining_object], process= gip\n",
    ")\n",
    "gip.iteration.interpretation_move = \"NewInterpretation\"\n",
    "gip.show(section)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wrong condition for condition_fold_constructor_dipping_anomaly: no DippingStratigraphyAnomaly\n",
      "Wrong condition for condition_fold_constructor_dip_variation_anomaly: no DipVariationAnomaly\n",
      "passing all internal checks\n",
      "will pass explanation check for folds\n",
      "epoch: 3\n",
      "situation: Features: mogi.internaldipvariationanomalytwoparts1, mogi.stratigraphic_part3\n",
      "Context: None\n",
      "Candidate explaining class: mogi.Chevron_Fold\n",
      "Explaining Object: mogi.fold_nb1\n",
      "Anomalies: None\n",
      "interpretation_move: NewInterpretation\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAACMCAYAAAB8r6P7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAsJElEQVR4nO3deVxUVf/A8c8Mm6hAIsgiCKQlFS5lapbmkpmWqZEtarlkbonm8mhWlpqPS6ZmaWmluSv1hFpaT5kJPphppv7KXHJjDXAPEBGEOb8/BgaGRQFhLsN836/XvJx775k733vuvczXe889R6eUUgghhBBC2AC91gEIIYQQQliKJD5CCCGEsBmS+AghhBDCZkjiI4QQQgibIYmPEEIIIWyGJD5CCCGEsBmS+AghhBDCZkjiI4QQQgibYa91ANWNwWAgKSkJFxcXdDqd1uEIIYQQogyUUqSnp+Pr64teX/p1HUl8ikhKSsLf31/rMISVmxYK058G3YCCjtHVeh1romHQMg0DE0KIGi4hIQE/P79Sl0viU4SLiwtgrDhXV1eNoxHWyiFhA/w+Cj/3BBIvFSTS/Xu3o8+732sYmRBC1ExpaWn4+/ubfsdLI4lPEfm3t1xdXSXxERXneQ8AQZ4xZomPfWacHFdCCFGFbtZMxSoaN8fGxjJ06FCCgoJwdnamcePGTJs2jezsbLNyOp2u2GvZMrmvIDRQNwiAoAYx5vMzkzQIRgghRD6ruOJz/PhxDAYDn3zyCU2aNOHPP/9k2LBhZGRkMH/+fLOyK1eupHv37qZpNzc3S4crBNTyAeB2zzMaByKEEKIwnVJK3bxY9fPee++xdOlSzpwp+GHR6XRs3ryZPn36VHi9aWlpuLm5kZqaKrckxK35VMe5qfWpez4DPQZquWbDi8ASqzzlhBCiWivr77dV3OoqSWpqKu7u7sXmh4WF4eHhQevWrVm2bBkGg0GD6ITNGzwYNkOD9y5Se901aq3Lho8AL8DFGa5d0zhAIYSwTVZxq6uo06dPs3jxYhYsWGA2f+bMmTzyyCM4Ozvz008/MXHiRC5cuMDUqVNLXVdWVhZZWVmm6bS0tCqLW9iIiRPBbTU8ChRuY6cDGgNLroG7K1zNLvnzQgghqoymt7qmT5/OjBkzblhm//793H///abppKQkOnbsSMeOHVm+fPkNP7tgwQLeeecdUlNTyx2D3OoSFXa7DmYCOog6Cm9FwKUM6NUSZvQFR3vgLHD5LXjnHW1jFUKIGqKst7o0TXwuXLjAhQsXblgmMDCQWrVqAcakp3PnzrRt25ZVq1bdsGdGgJ9//pn27duTkpKCl5dXiWVKuuLj7+8viY+omMWLwTAWPOH3OGj9FuR6gMEN9KdgRBf4eAiggGHOcPWq1hGLQtLT08nKysLDw0PrUIQQ5VTWxEfTW10eHh5l/gPz999/07lzZ1q1asXKlStvmvQAHDp0iFq1anHbbbeVWsbJyQknJ6eyhizEjf3nPzA07+0+UI5geBywA0NtWLM7L/HRAXUyQSmQoVGqhdzcXPr168exY8fYunUrd999t9YhCSGqgFW08UlKSqJTp040atSI+fPnc/78edMyb29vALZu3UpKSgrt2rXD2dmZyMhI3nzzTYYPHy6JjbCc06dNbx3tQRmA64AdkA0O+WecAnIABz2cvQD161s8VGEuJSWFo0ePEhMTQ7t27fjyyy957LHHtA5LCFHJrOKpru3bt3Pq1Cl27tyJn58fPj4+plc+BwcHPv74Y9q1a0fz5s354IMPeOedd4o1gBaiyowcCXclQbJxcmAHqGMH9l+DfhtwFCY9Xqh8FrAGaOkB//2v5eMVZho2bMi+ffto3749aWlpPP744yxZsgQwXg2Kiopi48aNREVFkZOTo3G0QoiKstp+fKqK9OMjKmTkSFCfQEdQYaBbDOjgRDLM/xYuZ0CPFjCko/HOljoBS3+DV/rnfX4DcNsAWLdOw40QYGz3N2LECFavXg1A9+7dOXr0GPHxcWblpk6dysyZM7UIUQhRAqto3FwdSeIjyq1Q0pNwDd5cDavrge4ZzB9nz5cGiRPAf4BxMuNhqG0HXABexdjg2dnZYuGL4pRSvPfee0yZMgWlFC713Bk//yP87whm2MP3mspFREQQGhqqYaRCiHyS+FSQJD6iXIokPY1+yZt9BD4+C7rxwG0YE6AcIBIM34Pdk+ar2dcK2uQfbmOAH/ZDoW4chOXl5ubi4+PDxYsXMRgM+ATeTnKssaf4p0e+StxfR7kQc4pTp05iZ2encbRCiBrfc7MQmisl6QFo8zToZgI7IOHFhqS80IDowQ9CG9AvBNUZhngXlG97AN7Ibxe9GBjbGt5+24IbI4qKjo7m/PnzjJ79PvW9fUxJT8Pbm9B/3GuEDh9DbGwM0dHRGkcqhCgPSXyEqIgbJD2fB8OQ/Hb3z0LvwG/w4SwP87Px6s+5vHJ3wQ8tCj43Jx5q74IcAxAGXJ8JLi6Qm2uRTRLmkpONrdTbPvo47375HX6N7zDOj4thx1cbaHRHsFk5IYR1kMRHiPIqa9IzyfhPkGeM+ee9HIyDleZCN3e41L5gUaYBHHbBqatAM+CTK+Bib/aYvLCM/KdGE04ep14DL+ZFfM9Dj/fCkJvL0qn/Ytm0yWblhBDWQRIfIcqjrEnPC0BsBgC3Nzhjvg51HXIVrOwM30I9B+Otr/ZuBUXu2AfL/s6bWA70agKfflpFGyVK0qFDBwICAon45EMMBgNOtZwZv2Apz46eAMDub7fg7OxMy5YttQ1UCFEukvgIUVblSXpyDeBQGyjhik++nTuhx1qYbpyMvg9WBRcsHnUCWu43du7Mm8C+EdCqVd4MUdXs7OxYuHABB6J28O7oIfx16DeuZWTQsn0nbr+7GQCZmZk8/PDDxMXF3WRtQojqQhIfIcqivElPoWEoSk18AF54AX6Kh5eMk4N8ILZdweLfr4A+Cs5lA48AEw+Cox4K9V4uqk5oaChfffUV58+c5I1+vXjh/jt5o18vDFevMGfOHLy8vDh8+DBt2rRhz549WocrhCgDSXyEuJlbSHrA/FbXtewShk/x94eruTC5IeyHgFqQ2wm8HAuKeP0M3+SP57saaNUAtm2rhI0TNxMaGsrp06eIjIxkw4YNREZGcurUSaZMmcL+/ftp0aIF586do3PnzuzatUvrcIUQNyGJjxA3cotJD0CAR8FtkPiLjUr+Hr0eEhPBaw68D3odpDwEM4MKivQ+DM/+mTcxF/jkSejX71a2TpSRnZ0dnTp1ol+/fnTq1MnUb4+/vz+7d++md+/etGjRgjZt2mgcqRDiZiTxEaI0lZD0ANRyzDK9jzkfVGIZkylTYMXvMMo4OTUQDhXqx/A/50EXCRm5QD/goXBjlnT1ajk3TlSWunXrsmnTJn744QecpcdtIao9SXyEKEklJT1FnTl3+80LNW8O567BACAeWrrAtY7mRer+D/amAu7AOsC/Dvz6a5liEJVPr9dTr149rcMQFnLkyBFk0APrJYmPEEVVUdIDEHMu74pP7rUbF3RyMj69FTcSVoGT3vjI+9BCXca0OwhTCvf2PKEtvPFGmWMRQpTfSy+9REhICFu2bNE6FFFBkvgIM7t372adLY8QXtlJj858DCfTra6M+LLFs3QpTPkJJhonlwfDj4V6e343Hhyj8np7fgXQzYHatSEnp2zrr2GOHz/OsGHDyMrKunlhDe3du5dVq1ZpHYaogIYNGwLw9ttvYzAYNI5GVIQkPsLkxIkTdO/enYEDB7JmzRqtw7G8qrjSU8e8TY/pVteVGzziXlSXLnD8H2Nvz9eha5Henq8rY2/PJ68C9wDLM8HNAU6dKvt31ACnT5/mkUceYfny5bz++utah1OqM2fO0K1bN4YMGcKKFSu0DkeU04QJE3B1deXPP//kq6++0jocUQGS+AiTJk2aMHDgQJRSDB482LaSn6q6vVXXvE1PwRWfMyUUvgE3N2Nvz+sfha0FvT13uq2gyJ374OP83p4/A/rcAcuWle97rFR8fDxdunQhKSmJe+65hzeq8S2/oKAghgwZAsDLL78syY+VqVevHhMmGHvvnj59Orkylp7VkcRHmOj1epYsWcKoUaOKJT+5ublERUWxceNGoqKiaszJnpubS1KvXlXWpoe65ld8Lme4G9+U54pPYdu3Q68NMM04GXkvrLmrYPHoE9Ds17zOnd8AfhvF5cBAoiIja9Q+K3wsJiQk0KVLF+Lj47nzzjvZsWMHHh4eWodZKp1Ox6JFixg7dixgnvzU1POsphk3bhz16tXj2LFjbNiwQfaZtVHCTGpqqgJUamqq1qFoJjc3V40aNUoBSqfTqTFjxqiAgEAFmF5ubrepiIgIrUOtsPj4eNWrVy+1rm5dpYaj1HpU/AoULxe8Pp9vnK/Wo5QOpQyG8n/RkblKrUfZ22UrYzqijOv7X99b24CEBKWcCuKLKxI7L6NSVhaK3x51e10X9dVXX93a92ooMTFRvfjii8WORXt7BwWooKAglZCQoHWYZWYwGNTYsWNN2zFq1KgSzjM3q95nNdmsWbPyjj97s30WEBBo1X8brVlZf7/lio8opuiVn8WLF6OrXYc54VuZv2UHAKmp//D000+zadMmjaOtmG7dutHjm28Y0P9K1VzpyZd3q6vYsBVXynmrqyg/P+NQ7m8Gwj5olNfbs2+h3p69f4Yt+SNbrIbT7ums7tvXavdZ69atWbt2LZfT05kTvpWlP/2Kd6NAcnKuAzB58mT8/Pw0jrLsil75Wbp0KdSqzZzwrby/NRKA1NRU+lrxPqvJAgICAMjJyaHvyFdZd+Akszd+A7Wcrfpvoy3QKSWdERSWlpaGm5sbqampuLq6ah2Opq5fv467e32uXElHp9PxwsQ3WTv/3wAMnjKdP/f9zIWYU5w6ddLUk601yM3NZaPbbbwwoIqTHoCLv8EPrXls7vdsP/wYAGq9DhzrQd9Lt7QdJu+9B+GTTU9+zY2D1wvlVaGeEBGSN/EFfLujDt3TUq1unwUGBpGYmADAPW3acS0jg9NH/qCepxcNb2/MlbPJVncsgvGH093dnfT0dAAGTHyD9QtmG99PeJ2/Dv1mledZTZabm0vjxk3ItXcg8fRJGvg1ov+4KSz61yumMgEBgZw+fUr2mQWV9fdbrviIUv38889cuZJO20d7oJQyJT0jZszjycHDCR0+htjYGKKjozWOtHzOPvWUZZIeMLXxKTxeFwDZlyu+zqImTYLVh029PU8JgN9bFyzelNfb85Uc4Dl4Yl4Gdg72kJFReTFUsejoaBITE5ix+j8AHPn1F04f+QPXeu5MW/kF/cdNscpjEYxdSKSnp/Ng9ycBTEnP0DdnEjp8jNWeZzVZdHQ0cXGxDHtrNm71PTiXGG9Kevya3MmUj1YSFxcr+6yaksRHlCo5ORmA0bMX8eizL5jmOzoZB9psdEewWTmrMHIkvj5by5T0bFy3/taSHgBHY2PmG47QXhlCQuB8lrG35zhoXrd4b88u0bAnFaiHsbfngLqwd2/VxlVJ8o8xv8ZNuatVWwAcazkzbeUX+De50zqPxTz5MY/69wK6Dxhimu+YN/yFNW9bTZW/Lxo3a0mvISMBsLO357P/HeSDbVGEtH3IrJyoXiqU+HTp0oUZM2YUm3/58mW6dOlyy0GJ6sHHx5gF/H36BMOnz+WxfoMAWPL6OKK2/If4k8fNylV75XhkXafAx9f31r8zL3EKalDFiQ+AoyNRkZEseQP4vKC35xGFNuOhgzApv3ufD4HJ7eC116o+tluUf4zNfWUQxw7so3ZdF2aujSAw+B4A6zsWC8mPOfHUX7w89d88/uJQAJZO/Rc7vtpg1dtWU+Xvi4STx+nxwhDcG3iTm5PDrz/9AFj38WgLKtTGR6/XU79+fR566CHWr19PnTp1ADh79iy+vr5W/TiftPEpkH8f2/P2O3jto5UALJ/5Jj9sXI1OpyMg+G7IvGodbQ/KkfS07tiVC7GnK2+7Nug4EHMf9089AEDuWj16vYL+ld+8Ln+fPVavPp8kH4CFxvk7L8Mj/1dQzk4H1x4Gez1wHJjrYBzo1N6+0mOqDJmZmdSvX5/MzEycnGvz9ooNBN9nHAndYDDw7ughVtsOpuh5ptPp+Hz223y31viIe0DTu9FlZVrlttVURffZDxtXs3zmm7h7+bD4+2jenzDKao9Ha1blbXx27NhBSkoKDzzwALGxsRVdjajG7OzsWLhwAQeidvDu6CGc/P0gA8a/TtuuxjY/sceO8OSTPav/iV3OpOfArp9YsGB+pW5X4VtdKanelbbeovL32We/H6TTnZ2NvT1nQZd68E+HgnK5eb09/3UVCAZWXTf29nziRJXFVlE5OTm8+OKLZGZmAhDQ9C50Oj2ZV67w16HfeHf0EA5E7aj0fWYpRc+zE/93gH5jJ9Mur81P3F9H6dGju1VuW01VdJ81uiMYdy9vLp1NZsqzT1j18WgTKvKsvE6nU2fPnlXXrl1T/fv3Vx4eHioyMlKlpKQovV5fkVVWG9KPT3ERERHF+hdxcXEx9fOzevVqrUMs3YgRZe6nB1CBgUGV3wfHepRhHaZ+fHa//aDxO6tQ4X32HSj1bMG2PjLJvB4+fLdQPTRDqSVLqjS28sjJyVEDBgxQgHJ0dFRTp04tdixWyT7TQMnnmavp/fLly7UOURRR0j6zs7NTGzZs0Do0m1TW3+8K/fXV6/Xq7NmzpumZM2cqJycn9fbbb0viU0Pl5OSoyMhItWHDBhUZGamys7PNOjmslslPOZKeDevXq8jISJWTk1P5ceR9T37is2bkC1We+Chlvs/+fOstpRoXbPP6heb1cddYY3Km1qPUMJQKCalYh42VKDc3Vw0dOtTUSdzXX39dbLuqbJ9ppOi2Xb9+3ayTQ0l+qp/8fbZmzRrl7e2tADV//nytw7JJZf39rnAbn5SUFBo0aGCaFxERwaBBg8jMzJQ2PjbCYDAQFhbG0qVL0el0HD58mHvuuUfrsIyqauytithgXLdugPFUm/H027wdOhP65YLOgg9WJiVBUEMwNtci8Rr4/2JeJPlB8HbKmxgMJKSAl5flYixk1qxZTJ06Fb1eT3h4OM8884wmcWhNKcW4ceP48MMPATh06BAtW7bUNihRos8//5yhQ4fi6enJmTNnqFu3rtYh2ZSy/n5XqCVjTEwMnp6eZvOefvppgoOD+e233yqySmGF8nt4BggMDJSkp4xMA5VmJkPthpb7Yl9fuGaAJk3g8TP4tTP29hz0C8RnGYv47DF2dhjqCawC2nrD+5vgqacsF2eeoUOH8uWXXzJp0iSbTXqgoIdnAE9PT0l6qrGBAwcye/ZsTp8+zUcffcRrVvDEpC2SnpuLkCs+5aeUQmfh5KFU5Uh69u/dR+s2bao+ps2+kJlsuuLzcPAudr3VCbpGQ4P2Vf/9JVm4ENZNhH8ZJ+fFwWuF+ljs5QFfN8ub+AqU6oNu82aLh3n9+nUcHBws/r3VUbU6z0Sp1q5dy8CBA2natClHjx5Fr7+1q7rXr18nNTW1Wg+8W11Iz83CYiryx/inn36i0nPuciQ9g18caJmkB6CO+Qjtpis+GRbo26c0EybAuiNg7HuNyQFwuFBvz99cMPb2nJ4D9AVd9y2g18GVKxYNU5KeAtXmPBM31L9/fxYvXsz+/ftvOenZuXMnTZs2ZdSoUZUUnQBJfIQGZs6cSdeuXZkyZUrl/VEu55WeVatXV873lkXeQKX5Ei42Mr651YFKb9Xdd8PFbGNvz2cgpC5kFent2TUadv8DuGDs7TnIBfbssXioovzmzp1L165dmThxoiQ/FmRnZ0dYWBguLi63vC5PT09iYmKIiIjg6NGjlRCdAEl8hAbc3Y3DOMybN69ykp9ytumx2JWefHWDSp5/RcMrPvkcHIwPm50bA8vBMa+351cKNT3qcAgmnMyb+AB4/SEMEyYQFRXFxo0biYqKsuoHGmqq/PPs/fffl+THSjVr1oynnnoKpRSzZ8/WOpwaQ9r4FCFtfCzjo48+IiwsDIDJkyczd+5cDAYD0dHRJCcn4+PjQ4cOHW7eAVg1b8gMwOmVsO8lfEf/TfI/xvEj1HodNHgYuu6yfDyliY6Gvg/D+8bJqMvQ+f/Mi2R3BAc9cAJyZ4ATkAv4+fkxb948+vXrZ9mYxQ19+umnjBgxAoDx48ezYMGCip1nQjMHDx6kVatW6PV6jh8/zh133KF1SNVWWX+/JfEpQhIfyymc/PTp04eDBw8RHx9nWu7t7cOHH35Q+hM91pD0AJzdBT914qHpu9lz0jh4oVqvg9p+0CdBm5hKk54Obq7wGeAMqTlwW5EBpo+1geA6eRMjYG7YNF6faxy7LyIigtDQUIuGLG6scPLTs2dP/vjjcLHz7IMPFvHss89qFaK4iZ49e/Ltt98yePBgBg0aJElrKWpc4+bAwEB0Op3Za8qUKWZl4uPjefLJJ6lTpw4eHh6MHTuW7OxsjSIWNzN69GjT4/BbtmwhGx2zN37DugMn6fbcC6SkJPPss8+yadOm4h+2lqQHTLe6bm9QpE3P1UQNgrkJFxcwKNj8BGwGN3vjra/H3AuK3PUrfJCfr30CU76bwRjA/46mTJz4L7ntVc0MHz6cTz75BIBt27aRZVCm86zHgCGkpCTz3HPPlXyeiWph6tSpAKxatYrOnTvTv39/OnfuTOPGTWS/VYDVJD4A77zzDsnJyaZX/sEAxkHjnnjiCTIyMti9ezfh4eFEREQwceJEDSMWNzNy5EhTW4SU+Fh+/el7fvxyHdu/WAdASNsHi/+YWlPSA+BsbDBjkRHaK8u2bfDsl/CWcfL7FhB+d8Hicaeg6V5j8yBegw9HwMGMDGJjY4iOji5xlUI7Q4cOxd29PgBnE+PZ8/02Ijd/yX/XG3uzvKdNO0laq7GkpCTT+zZdu7PuwEnmhG/FvVEQTz/9tCQ/5WRViY+Liwve3t6mV+FeMbdv387Ro0dZt24d9957L127dmXBggV89tlnpKWlaRi1uJHo6GguXbpEryHG56q3LP+Y1e8ab5ss2/kr/cdNMf8xtbakB0BvvBRdeKBSq/DMM7A7CYYYJ5/zgsQHCxafyAR9FCRnAQ+Dx3uJKAe4fOyYFtGKGzCeZxd56uXRAGxb/Skr/v0mAB/9+AsDxr8uSWs1lZuby4QJE2l67/0AHNy1k9QL5/ghfC2HoiMBePXVcZK0loNVJT7vvvsu9evXp2XLlsyaNcvsNtYvv/xCSEgIvr6+pnmPPfYYWVlZHDhwoNR1ZmVlkZaWZvYSlpOcnAzAs2ETefmtWab53Z5/EQ+fhjS6I7ignDUmPYUUu9VlDXx8jL09z7gTdkNDJzB0gttrFRTx3QP/OZc3sQqemvsKjBoFr74K06dDfLzl4xZm8s+zp0eNY8SMeab5nUOfx8uvkfl5JqqV6Oho4uJiGfzaNO6+/wFyrmcz+rGHiNryJQCtu3QjMTFBktZysJrE59VXXyU8PJzIyEjCwsJYtGgRr7zyiml5SkoKXkXGFKpXrx6Ojo6kpKSUut45c+bg5uZmevn7+1fZNojifHyM2UrCyeP0GDDElPxsD1/LugWziDthvHrQceNGq056wPyKT+pVK2o4r9PBX39haLIA5hknT7eDBY0Lijx7BHr+AawBXAHPZXD7h1B7BowLgOYhcO5cKV8gqlrh86zbcy+Ykp/ITeGsmjvDdJ7llxPVR34y6n9HMH1fGWea32fYaL48ksCr85aYlRM3p2niM3369GINlou+8sf+Gj9+PB07dqR58+a8/PLLLFu2jBUrVnDx4kXT+krq2fRm3by//vrrpKamml4JCdXsKZsarkOHDgQEBBLxyYcYDAaz5GfL8o9ZPOVV1tWti6/PVqtOegAauv9teh97PlC7QCpIP2ECP770ARgfEGJCIzhSqEukQV8AdwNTgGDAE/AD+gJjjkDr2+HSJQtHLaD4eVY4+dm2+lM+nDyGgIBAOnTooHGkoqjCSWvzdh24s0UrAAy5udjZ2RF/8rhZOXFzmiY+YWFhHDt27IavkJCQEj/7wAMPAHDq1CkAvL29i13ZuXz5MtevXy92JagwJycnXF1dzV7Ccuzs7Fi4cAEHonbw7ugh/HXoNzr1foYnhxh/XafFxzKg/xWrT3oA7PQG0/sz526/Qcnq69GxY9m84gtjb8+n4O46xr59Hk2Evh2A+wEdbNoP49bC3G8g9SpQB3g9A3r11DR+W1XSedbhiT70edl41fxsYjzNmoXc8hALovIVTlqVUqarPtvD1/DPxQts+nQxgYFBkrSWh7JSW7duVYCKi4tTSin13XffKb1er5KSkkxlwsPDlZOTk0pNTS3zelNTUxVQrs+IWxcREaECAgIVYHp97uSk1HCUWo+KX4Hi5YLX5/ON89V6lNKhlMGg9SbcWF6sxueglFowYLxxnpXKyclR8X37KtUxbx8EoNQq4/uZfY37z+E2lJ0D6i4/1JUVeeU6opScW5op6TyrX7++6f348eOVobqfSzYoIiJC6XQ6dX/nR9WsDV+rwOB7FKC8A4KUTqdTERERWodYLZT199sqOjD85Zdf2Lt3L507d8bNzY39+/czfvx47r//fr7++mvA2PK9ZcuWeHl58d5773Hp0iUGDx5Mnz59WLx4cZm/Szow1E5ubq6pR9mOGzfWiNtbJhuM8eWP0B7WbTGLB42FvpfB8TYNA7tFu3dDaAe4DZgO13Og9kuQczfQFrgEbIJVI2DQw8CfwH3/gb59tYvZxhU+z/I7wVuxYkWxHp5lJPjqZdOmTUyYMJG4uFjTPJ1Ox6pVqxg4cKB2gVUjZf39trdgTBXm5OTEF198wYwZM8jKyiIgIIBhw4YxefJkUxk7Ozu+/fZbXnnlFR566CGcnZ3p378/8+fP1zByUR52dnZ06tTJ+PRWTUp6AOxdICfdNGm61ZURC44tNQmpUrRvD6fToI3xj8y165CTizERAnA1Ps2flpk37QBkZFg+TmFiOs8KGT58OAAjRozg/fffx9nZmVmzZpXwaaGV0NBQevfuTXR0NH///TdvvfUWMTExxMRYWTcZ1YBVJD733Xcfe/fuvWm5Ro0asW3bNgtEJKqMlT+yXqq6QfDPH6bJmHN5A5deiYF6LbWJqbK4uECmF6izuDhDh2D45TfIuQr6FLDTQdf8pnqxQP8HNAxWlCY/+Zk0aRJPPPGExtGIkhROWu3t7Xn++edZtGgR48ePlzsU5SAt2YS2kpKgXz9oWB8C7GH9J5AECWk1KOkBqGvemDnmfH7iY4V9+5Rk4HBjUgNEvArd7wKXY9DYAFsnwl0NAQOw2xuaNtUwUHEjw4cP59SpUzz44IM3Lyw01bdvX5o2bco///zDxx9/rHU4VkUSH6GdTz+F3g2hfTjMuwRzcmEZ0B7qz4TmeT0VWH3SA1AnyGzy2nVn45srNeQy9dSp8OltkAmersZkJ+0zODEfHmuOsensWmDhMm3jFDfl6empdQiiDOzs7HjjjTcAWLBgAVevXtU4IushiY/Qxo8/whcjYBxQD9CBwWD8F3+oPQf2HYB1jWpA0gOmgUpdahXpGTyjhiQ+jo7wyxF4pz4cAfJ7z1fAeeB9oM/H0Lu3ZiEKUdP079+f/v37s3HjRpydnbUOx2pYRRsfUQOFDYepgA62/wEvLYfkS9AyCL4YDU28oda/YMAXwCtYd9IDpltdQQ1i+CO+RcH8mnKrC8DXF2LOwfLl8O6HcCkF7GtBt+6wfR64u998HUKIMrO3t2f9+vVah2F15IqPsLwLFyAkFuyMv5O9FkKSMxjawe8Xoft7xhwHdyAR6096wHTFp9h4XTXlVlc+vR6GD4c//4SkCxCfaEyEJOkRQlQTkvgIy/vjDwg0vv35BGRdB9UZuBty28LpFEi4iPG2VyDWn/QA1AkEShih3ZBl+ViEEMKGSeIjLO+22yCvX5f6dfPmnS/4V6cDt9p505l66096AOyNG1Qs8RFCCGFRkvgIy2vZEv5nDwoebQaPhIDuB3DYCByCt/pAvToYG8imWeeYVqUpdqtLCCGERUnjZmF5ej00fwaSNmLfEP47CdbshvgLxgG8e96XV24XMP3fWkZa6Qpf8cnOccDR/rqG0QghhO2RxEdoY80aaLoLxiTh0ACGdiq0TAEHgQu94bnntImvigR6xpreJ1z0p7GXXAESQghLkltdQhv29nDkNHz/GHwE/IXxCa7fgX87ABNgyxYtI6wStZ0yTe9N43UJIYSwGLniI7RTqxZ8/z1cvQrr1sG5c9A6GOaEGm+H1XCmYSuEEEJYjCQ+Qnu1axv7frExpoFKc7PBzlHbYIQQwkbU/P9WC1FtmD+Wb7rVdTVeg1iEEMI2SeIjhKXUNb+1VTBCu/TtI4QQliKJjxCWUte8MXNB4iNPdgkhhKVIG58ilFIApKWl3aSkEOVTy9GPwi15LqR7ApB16RhZcrwJIcQtyf/dzv8dL41O3ayEjUlMTMTf31/rMIQQQghRAQkJCfj5+ZW6XBKfIgwGA0lJSbi4uKCr5mNEpaWl4e/vT0JCAq6urlqHU6NJXVuO1LXlSF1bjtR11VNKkZ6ejq+vL/obdIkit7qK0Ov1N8wUqyNXV1c5kSxE6tpypK4tR+racqSuq5abm9tNy0jjZiGEEELYDEl8hBBCCGEzJPGxYk5OTkybNg0nJyetQ6nxpK4tR+racqSuLUfquvqQxs1CCCGEsBlyxUcIIYQQNkMSHyGEEELYDEl8hBBCCGEzJPGxYh9//DFBQUHUqlWLVq1aER0drXVIVm369OnodDqzl7e3t2m5Uorp06fj6+uLs7MznTp14siRIxpGbD3+97//8eSTT+Lr64tOp2PLli1my8tSt1lZWYwZMwYPDw/q1KlDr169SExMtOBWWIeb1fXgwYOLHecPPPCAWRmp65ubM2cOrVu3xsXFhQYNGtCnTx/++usvszJyXFdPkvhYqS+++IJx48bx5ptvcujQITp06ECPHj2Ij4/XOjSrds8995CcnGx6HT582LRs3rx5LFy4kCVLlrB//368vb159NFHSU9P1zBi65CRkUGLFi1YsmRJicvLUrfjxo1j8+bNhIeHs3v3bq5cuULPnj3Jzc211GZYhZvVNUD37t3NjvPvvvvObLnU9c3t2rWL0aNHs3fvXn788UdycnLo1q0bGRkZpjJyXFdTSlilNm3aqJEjR5rNCw4OVlOmTNEoIus3bdo01aJFixKXGQwG5e3trebOnWuad+3aNeXm5qaWLVtmoQhrBkBt3rzZNF2Wuv3nn3+Ug4ODCg8PN5X5+++/lV6vV99//73FYrc2RetaKaUGDRqkevfuXepnpK4r5ty5cwpQu3btUkrJcV2dyRUfK5Sdnc2BAwfo1q2b2fxu3bqxZ88ejaKqGU6ePImvry9BQUE8//zznDlzBoCYmBhSUlLM6tzJyYmOHTtKnd+istTtgQMHuH79ulkZX19fQkJCpP4rICoqigYNGnDnnXcybNgwzp07Z1omdV0xqampALi7uwNyXFdnkvhYoQsXLpCbm4uXl5fZfC8vL1JSUjSKyvq1bduWNWvW8MMPP/DZZ5+RkpLCgw8+yMWLF031KnVe+cpStykpKTg6OlKvXr1Sy4iy6dGjB+vXr2fnzp0sWLCA/fv306VLF7KysgCp64pQSjFhwgTat29PSEgIIMd1dSaDlFqxoqPHK6Wq/Yjy1VmPHj1M75s1a0a7du1o3Lgxq1evNjX+lDqvOhWpW6n/8nvuuedM70NCQrj//vsJCAjg22+/JTQ0tNTPSV2XLiwsjD/++IPdu3cXWybHdfUjV3yskIeHB3Z2dsX+R3Du3Lli/7sQFVenTh2aNWvGyZMnTU93SZ1XvrLUrbe3N9nZ2Vy+fLnUMqJifHx8CAgI4OTJk4DUdXmNGTOGb775hsjISPz8/Ezz5biuviTxsUKOjo60atWKH3/80Wz+jz/+yIMPPqhRVDVPVlYWx44dw8fHh6CgILy9vc3qPDs7m127dkmd36Ky1G2rVq1wcHAwK5OcnMyff/4p9X+LLl68SEJCAj4+PoDUdVkppQgLC2PTpk3s3LmToKAgs+VyXFdjmjWrFrckPDxcOTg4qBUrVqijR4+qcePGqTp16qjY2FitQ7NaEydOVFFRUerMmTNq7969qmfPnsrFxcVUp3PnzlVubm5q06ZN6vDhw6pfv37Kx8dHpaWlaRx59Zeenq4OHTqkDh06pAC1cOFCdejQIRUXF6eUKlvdjhw5Uvn5+akdO3aogwcPqi5duqgWLVqonJwcrTarWrpRXaenp6uJEyeqPXv2qJiYGBUZGanatWunGjZsKHVdTqNGjVJubm4qKipKJScnm15Xr141lZHjunqSxMeKffTRRyogIEA5Ojqq++67z/QYpaiY5557Tvn4+CgHBwfl6+urQkND1ZEjR0zLDQaDmjZtmvL29lZOTk7q4YcfVocPH9YwYusRGRmpgGKvQYMGKaXKVreZmZkqLCxMubu7K2dnZ9WzZ08VHx+vwdZUbzeq66tXr6pu3bopT09P5eDgoBo1aqQGDRpUrB6lrm+upDoG1MqVK01l5LiunmR0diGEEELYDGnjI4QQQgibIYmPEEIIIWyGJD5CCCGEsBmS+AghhBDCZkjiI4QQQgibIYmPEEIIIWyGJD5CCCGEsBmS+AghhBDCZkjiI4QQQgibIYmPEEIIIWyGJD5CCCGEsBmS+AgharTz58/j7e3N7NmzTfP27duHo6Mj27dv1zAyIYQWZJBSIUSN991339GnTx/27NlDcHAw9957L0888QSLFi3SOjQhhIVJ4iOEsAmjR49mx44dtG7dmt9//539+/dTq1YtrcMSQliYJD5CCJuQmZlJSEgICQkJ/PbbbzRv3lzrkIQQGpA2PkIIm3DmzBmSkpIwGAzExcVpHY4QQiNyxUcIUeNlZ2fTpk0bWrZsSXBwMAsXLuTw4cN4eXlpHZoQwsIk8RFC1HiTJk3iq6++4vfff6du3bp07twZFxcXtm3bpnVoQggLk1tdQogaLSoqikWLFrF27VpcXV3R6/WsXbuW3bt3s3TpUq3DE0JYmFzxEUIIIYTNkCs+QgghhLAZkvgIIYQQwmZI4iOEEEIImyGJjxBCCCFshiQ+QgghhLAZkvgIIYQQwmZI4iOEEEIImyGJjxBCCCFshiQ+QgghhLAZkvgIIYQQwmZI4iOEEEIImyGJjxBCCCFsxv8DxjwTL58JjnUAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "gip.do()\n",
    "gip.check()\n",
    "gip.act()\n",
    "gip.show(section)\n",
    "print(gip.iteration)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Interpreted Objects:\n",
      "- stratigraphic_part1\n",
      "- stratigraphic_part2\n",
      "- stratigraphic_part3\n",
      "- fold_nb1\n",
      "\n",
      "Anomalies:\n",
      "- dippingstratigraphyanomaly1\n",
      "- dippingstratigraphyanomaly2\n",
      "- internaldipvariationanomalytwoparts1\n"
     ]
    }
   ],
   "source": [
    "print(\"Interpreted Objects:\\n- \"+\"\\n- \".join([obj_i.name for obj_i in gip.interpreted_objects]))\n",
    "print(\"\\nAnomalies:\\n- \"+\"\\n- \".join([obj_i.name for obj_i in gip.anomalies]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iteration 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 4\n",
      "epoch: 4\n",
      "situation: Features: mogi.D1, mogi.D2\n",
      "Context: None\n",
      "Candidate explaining class: mogi.Stratigraphic_Part\n",
      "Explaining Object: mogi.stratigraphic_part6\n",
      "Anomalies: mogi.dippingstratigraphyanomaly3\n",
      "interpretation_move: NewInterpretation\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plan the iteration\n",
    "gip.new_epoch()\n",
    "print(\"Iteration:\",gip.iteration.epoch)\n",
    "gip.iteration.situation = InterpretationSituation(\n",
    "    features= [mogi().D1, mogi().D2], process= gip\n",
    ")\n",
    "gip.iteration.interpretation_move = \"NewInterpretation\"\n",
    "gip.do()\n",
    "gip.check()\n",
    "gip.act()\n",
    "gip.show(section)\n",
    "print(gip.iteration)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Interpreted Objects:\n",
      "- stratigraphic_part1\n",
      "- stratigraphic_part2\n",
      "- stratigraphic_part3\n",
      "- fold_nb1\n",
      "- stratigraphic_part6\n",
      "\n",
      "Anomalies:\n",
      "- dippingstratigraphyanomaly1\n",
      "- dippingstratigraphyanomaly2\n",
      "- internaldipvariationanomalytwoparts1\n",
      "- dippingstratigraphyanomaly3\n"
     ]
    }
   ],
   "source": [
    "print(\"Interpreted Objects:\\n- \"+\"\\n- \".join([obj_i.name for obj_i in gip.interpreted_objects]))\n",
    "print(\"\\nAnomalies:\\n- \"+\"\\n- \".join([obj_i.name for obj_i in gip.anomalies]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iteration 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 5\n",
      "sides [mogi.shared_side_nb_2, mogi.side1]\n",
      "sides [mogi.shared_side_nb_2, mogi.side1]\n",
      "sides [mogi.shared_side_nb_2, mogi.side1]\n",
      "sides [mogi.shared_side_nb_2, mogi.side1]\n",
      "sides [mogi.shared_side_nb_2, mogi.side1]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 5\n",
      "situation: Features: mogi.stratigraphic_part3, mogi.stratigraphic_part6\n",
      "Context: None\n",
      "Candidate explaining class: mogi.Stratigraphic_Part\n",
      "Explaining Object: mogi.stratigraphic_part7\n",
      "Anomalies: mogi.internaldipvariationanomalymultiparts1\n",
      "interpretation_move: NewInterpretation\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plan the iteration\n",
    "gip.new_epoch()\n",
    "print(\"Iteration:\",gip.iteration.epoch)\n",
    "gip.iteration.situation = InterpretationSituation(\n",
    "    features= [gip.history[-3].situation.explaining_object,gip.history[-1].situation.explaining_object], process= gip\n",
    ")\n",
    "gip.iteration.interpretation_move = \"NewInterpretation\"\n",
    "gip.do()\n",
    "gip.check()\n",
    "gip.act()\n",
    "gip.show(section)\n",
    "print(gip.iteration)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iteration 8\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 6\n",
      "Warning: stratigraphic_part9 and stratigraphic_part4 already limbs of an existing fold fold_nb1. This latter will be returned\n",
      "Warning: stratigraphic_part4 and stratigraphic_part4 already limbs of an existing fold fold_nb1. This latter will be returned\n",
      "sides [mogi.shared_side_nb_2, mogi.side1]\n",
      "sides [mogi.shared_side_nb_2, mogi.side1]\n",
      "sides [mogi.shared_side_nb_2, mogi.side1]\n",
      "will pass explanation check for folds\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 6\n",
      "situation: Features: mogi.internaldipvariationanomalymultiparts1, mogi.D1, mogi.D2\n",
      "Context: None\n",
      "Candidate explaining class: mogi.Fold_Train\n",
      "Explaining Object: mogi.fold_train1\n",
      "Anomalies: None\n",
      "interpretation_move: NewInterpretation\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plan the iteration\n",
    "gip.new_epoch()\n",
    "print(\"Iteration:\",gip.iteration.epoch)\n",
    "gip.iteration.situation = InterpretationSituation(\n",
    "    features= [gip.history[-1].situation.anomalies[0], mogi().D1, mogi().D2], process= gip\n",
    ")\n",
    "gip.iteration.interpretation_move = \"NewInterpretation\"\n",
    "gip.do()\n",
    "gip.check()\n",
    "gip.act()\n",
    "gip.show(section)\n",
    "print(gip.iteration)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Forging manually the surfaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_part1_coo = [[32., 0, -54.], [ 32.,   45, -54 ], [-2., 45., -25], [ -2.,   0, -25. ]]\n",
    "my_part2_coo = [[32., 45, -54.], [ 32.,   0, -54 ], [58., 0., -26], [ 58.,   45, -26. ]]\n",
    "my_part3_coo = [[58., 45., -26.], [ 58.,   0., -26 ], [93., 0., -54], [ 93.,   45, -54. ]]\n",
    "my_part4_coo = [[115., 0., -25.], [ 115.,   45., -25 ], [93., 45., -54], [ 93.,   0, -54. ]]\n",
    "my_part5_coo = [[115., 0., -25.], [ 155.,   0., -54 ], [155., 45., -54], [ 115.,   45, -25. ]]\n",
    "my_part6_coo = [[191., 0., -25.], [ 191.,   45., -25 ], [155., 45., -54], [ 155.,   0, -54. ]]\n",
    "my_part7_coo = [[191., 0., -25.], [ 213.,   0., -54 ], [213., 45., -54], [ 191.,   45, -25. ]]\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_manual_coords = [my_part1_coo, my_part2_coo, my_part3_coo, my_part4_coo\n",
    "                      , my_part5_coo, my_part6_coo, my_part7_coo]\n",
    "list_nodes_manu = list_coords_to_list_nodes(list_manual_coords, mogi, sp.coordinate_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "planars = list_of_planars_from_nodes(list_nodes_manu, mogi)\n",
    "my_parts = list_of_parts_from_nodes(planars, mogi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_cplx = mogi().Complex_Surface(has_Part = planars)\n",
    "attribute_parts_nodes_to_complex_surface(final_cplx)\n",
    "compute_center_complex_surface(mogi, sp, final_cplx )\n",
    "final_part = create_surface_part(mogi, final_cplx)\n",
    "final_cplx.non_planar = True\n",
    "final_part.deformed = True\n",
    "neighbor_constructor_from_multiple_planars(final_cplx, mogi, sp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "anomaly = internal_dip_variation_anomaly_multi_parts_constructor(mogi, final_part)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iteration 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 7\n",
      "epoch: 7\n",
      "situation: Features: mogi.internaldipvariationanomalymultiparts2\n",
      "Context: None\n",
      "Candidate explaining class: mogi.Fold_Train\n",
      "Explaining Object: mogi.fold_train2\n",
      "Anomalies: None\n",
      "interpretation_move: NewInterpretation\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plan the iteration\n",
    "gip.new_epoch()\n",
    "print(\"Iteration:\",gip.iteration.epoch)\n",
    "gip.iteration.situation = InterpretationSituation(\n",
    "    features= [anomaly], process= gip\n",
    ")\n",
    "gip.iteration.interpretation_move = \"NewInterpretation\"\n",
    "gip.do()\n",
    "\n",
    "gip.show(section)\n",
    "print(gip.iteration)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 7\n",
      "situation: Features: mogi.internaldipvariationanomalymultiparts2\n",
      "Context: None\n",
      "Candidate explaining class: mogi.Fold_Train\n",
      "Explaining Object: mogi.fold_train2\n",
      "Anomalies: None\n",
      "interpretation_move: NewInterpretation\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "gip.show(section)\n",
    "print(gip.iteration)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "gip.new_epoch()\n",
    "gip.show(section, draw_explanation=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing DataSet & Manual entries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs = mogi().search(type=mogi().PointBased_Observation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "instance: mogi.D1\n",
      "types: mogi.PointBased_Observation\n",
      "properties:\n",
      "|- has_Representation:[mogi.D1_point]\n",
      "|- is_Explained_By:[mogi.stratigraphic_part6]\n",
      "|- polarity:[True]\n",
      "|- is_Observation_Of:[mogi.Trias_Base]\n",
      "|- size:[10]\n",
      "|- occurrence:[True]\n",
      "|- has_Center:[mogi.D1_point]\n",
      "|- dip_dir:[90.0]\n",
      "|- dip:[45.0]\n"
     ]
    }
   ],
   "source": [
    "if len(obs) > 0 : \n",
    "    mogi.show_instance_qualities(obs[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A dataset of type: GeologicalDataset\n",
      "- The dataset is empty\n",
      "- Extension: None\n",
      "- Number of spaces this dataset is attached to: 1\n",
      " |- Physical space:Representation space of type: PhysicalRepresentationSpace\n",
      " | |- Number of dimension(s): 0\n",
      " | |- Coordinate label(s): []\n",
      " | |- Space extension:\n",
      " |- Temporal space: None\n"
     ]
    }
   ],
   "source": [
    "dataset= GeologicalDataset()\n",
    "dataset.remove_all_observations()\n",
    "print(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>dip_dir</th>\n",
       "      <th>dip</th>\n",
       "      <th>geology</th>\n",
       "      <th>occurrence</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [dip_dir, dip, geology, occurrence]\n",
       "Index: []"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.get_observations(observation_type= mogi().PointBased_Observation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of instances: 0\n"
     ]
    }
   ],
   "source": [
    "mogi.show_all_instance_qualities(dataset.get_observations())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.remove_observation_by_name(\"D8\")\n",
    "dataset.get_observations()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A dataset of type: GeologicalDataset\n",
      "- The dataset is empty\n",
      "- Extension: None\n",
      "- Number of spaces this dataset is attached to: 1\n",
      " |- Physical space:Representation space of type: PhysicalRepresentationSpace\n",
      " | |- Number of dimension(s): 0\n",
      " | |- Coordinate label(s): []\n",
      " | |- Space extension:\n",
      " |- Temporal space: None\n"
     ]
    }
   ],
   "source": [
    "dataset.remove_all_observations()\n",
    "print(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A dataset of type: GeologicalDataset\n",
      "- Size of dataset: 2\n",
      "- Types of data:\n",
      " |- occurrence:\t2 entries\n",
      " |- orientation:\t0 entries\n",
      "- Extension:\n",
      " |- Coord x: [1.0, 3.0]\n",
      " |- Coord y: [0.0, 0.0]\n",
      " |- Coord z: [1.0, 2.0]\n",
      "- Number of spaces this dataset is attached to: 2\n",
      " |- Physical space:Representation space of type: PhysicalRepresentationSpace\n",
      " | |- Number of dimension(s): 3\n",
      " | |- Coordinate label(s): ['x', 'y', 'z']\n",
      " | |- Space extension:\n",
      " | | |- Coord x: [0.6 3.4]\n",
      " | | |- Coord y: [-1.05  1.05]\n",
      " | | |- Coord z: [0.8 2.2]\n",
      " |- Temporal space: None\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[mogi.DD, mogi.DN]"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "physical_space = PhysicalRepresentationSpace(coordinate_labels= [\"x\",\"y\",\"z\"])\n",
    "dataset.setup_representation_space(physical_space= physical_space)\n",
    "dataset.add_occurrence_observation(name=\"DD\", observed_object= \"Keuper\", x= 1, z= 2, y= 0, occurrence= True)\n",
    "dataset.add_occurrence_observation(name=\"DN\", observed_object= \"Keuper\",  x= 3, z= 1, y= 0)\n",
    "dataset.update_extension()\n",
    "print(dataset)\n",
    "\n",
    "dataset.get_observations()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>z</th>\n",
       "      <th>dip_dir</th>\n",
       "      <th>dip</th>\n",
       "      <th>geology</th>\n",
       "      <th>occurrence</th>\n",
       "      <th>has_Representation</th>\n",
       "      <th>has_Center</th>\n",
       "      <th>size</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>DD</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.DD_point</td>\n",
       "      <td>mogi.DD_point</td>\n",
       "      <td>0.10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DN</th>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.DN_point</td>\n",
       "      <td>mogi.DN_point</td>\n",
       "      <td>0.28</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        x    y    z  dip_dir  dip geology  occurrence has_Representation   \n",
       "name                                                                       \n",
       "DD    1.0  0.0  2.0      NaN  NaN     nan        True      mogi.DD_point  \\\n",
       "DN    3.0  0.0  1.0      NaN  NaN     nan        True      mogi.DN_point   \n",
       "\n",
       "         has_Center  size  \n",
       "name                       \n",
       "DD    mogi.DD_point  0.10  \n",
       "DN    mogi.DN_point  0.28  "
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A dataset of type: GeologicalDataset\n",
      "- Size of dataset: 3\n",
      "- Types of data:\n",
      " |- occurrence:\t3 entries\n",
      " |- orientation:\t1 entries\n",
      "- Extension:\n",
      " |- Coord x: [1.0, 3.0]\n",
      " |- Coord y: [0.0, 0.0]\n",
      " |- Coord z: [1.0, 2.0]\n",
      "- Number of spaces this dataset is attached to: 2\n",
      " |- Physical space:Representation space of type: PhysicalRepresentationSpace\n",
      " | |- Number of dimension(s): 3\n",
      " | |- Coordinate label(s): ['x', 'y', 'z']\n",
      " | |- Space extension:\n",
      " | | |- Coord x: [0.6 3.4]\n",
      " | | |- Coord y: [-1.05  1.05]\n",
      " | | |- Coord z: [0.8 2.2]\n",
      " |- Temporal space: None\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[mogi.DD, mogi.DN, mogi.DO]"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.add_orientation_observation(name=\"DO\", observed_object= \"Trias\", dip= 30, dip_dir= 270, x= 2, z= 2, y= 0)\n",
    "print(dataset)\n",
    "\n",
    "dataset.get_observations()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>z</th>\n",
       "      <th>dip_dir</th>\n",
       "      <th>dip</th>\n",
       "      <th>geology</th>\n",
       "      <th>occurrence</th>\n",
       "      <th>has_Representation</th>\n",
       "      <th>has_Center</th>\n",
       "      <th>size</th>\n",
       "      <th>polarity</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>DD</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.DD_point</td>\n",
       "      <td>mogi.DD_point</td>\n",
       "      <td>0.10</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DN</th>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.DN_point</td>\n",
       "      <td>mogi.DN_point</td>\n",
       "      <td>0.28</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DO</th>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>270.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.DO_point</td>\n",
       "      <td>mogi.DO_point</td>\n",
       "      <td>0.28</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        x    y    z  dip_dir   dip geology  occurrence has_Representation   \n",
       "name                                                                        \n",
       "DD    1.0  0.0  2.0      NaN   NaN     nan        True      mogi.DD_point  \\\n",
       "DN    3.0  0.0  1.0      NaN   NaN     nan        True      mogi.DN_point   \n",
       "DO    2.0  0.0  2.0    270.0  30.0     nan        True      mogi.DO_point   \n",
       "\n",
       "         has_Center  size polarity  \n",
       "name                                \n",
       "DD    mogi.DD_point  0.10      NaN  \n",
       "DN    mogi.DN_point  0.28      NaN  \n",
       "DO    mogi.DO_point  0.28     True  "
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### From file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A dataset of type: GeologicalDataset\n",
      "- Size of dataset: 24\n",
      "- Types of data:\n",
      " |- occurrence:\t0 entries\n",
      " |- orientation:\t23 entries\n",
      "- Extension:\n",
      " |- Coord x: [2.0, 198.0]\n",
      " |- Coord y: [7.0, 140.0]\n",
      " |- Coord z: [2.0, 18.0]\n",
      "- Number of spaces this dataset is attached to: 1\n",
      " |- Physical space:Representation space of type: PhysicalRepresentationSpace\n",
      " | |- Number of dimension(s): 3\n",
      " | |- Coordinate label(s): ['x', 'y', 'z']\n",
      " | |- Space extension:\n",
      " | | |- Coord x: [-38.4 237.4]\n",
      " | | |- Coord y: [-28. 168.]\n",
      " | | |- Coord z: [-2.4 21.4]\n",
      " |- Temporal space: None\n"
     ]
    }
   ],
   "source": [
    "dataset = load_dataset_from_csv(\"../inputs/data_for_paper.csv\", sep=\";\", index= \"Id\", coordinate_labels=[\"x\",\"y\",\"z\"], labels={\"ID\":\"Id\", \"strike\":\"dip_dir\",\"name\":\"observed_object\"})\n",
    "print(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>z</th>\n",
       "      <th>dip_dir</th>\n",
       "      <th>dip</th>\n",
       "      <th>geology</th>\n",
       "      <th>occurrence</th>\n",
       "      <th>has_Representation</th>\n",
       "      <th>polarity</th>\n",
       "      <th>is_Observation_Of</th>\n",
       "      <th>size</th>\n",
       "      <th>has_Center</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>D1</th>\n",
       "      <td>198.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.00</td>\n",
       "      <td>45.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D1_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.unit_x</td>\n",
       "      <td>13.79</td>\n",
       "      <td>mogi.D1_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D2</th>\n",
       "      <td>196.0</td>\n",
       "      <td>120.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>2.00</td>\n",
       "      <td>46.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D2_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.unit_x</td>\n",
       "      <td>13.79</td>\n",
       "      <td>mogi.D2_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D3</th>\n",
       "      <td>191.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>0.01</td>\n",
       "      <td>46.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D3_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.unit_x</td>\n",
       "      <td>13.79</td>\n",
       "      <td>mogi.D3_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D4</th>\n",
       "      <td>165.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>180.00</td>\n",
       "      <td>45.5</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D4_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.unit_x</td>\n",
       "      <td>13.79</td>\n",
       "      <td>mogi.D4_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D5</th>\n",
       "      <td>152.0</td>\n",
       "      <td>67.5</td>\n",
       "      <td>8.0</td>\n",
       "      <td>2.00</td>\n",
       "      <td>44.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D5_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.unit_x</td>\n",
       "      <td>13.79</td>\n",
       "      <td>mogi.D5_point</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          x      y    z  dip_dir   dip geology  occurrence has_Representation   \n",
       "name                                                                            \n",
       "D1    198.0   22.0  2.0     1.00  45.0     nan        True      mogi.D1_point  \\\n",
       "D2    196.0  120.0  4.0     2.00  46.0     nan        True      mogi.D2_point   \n",
       "D3    191.0   15.0  9.0     0.01  46.0     nan        True      mogi.D3_point   \n",
       "D4    165.0   80.0  5.0   180.00  45.5     nan        True      mogi.D4_point   \n",
       "D5    152.0   67.5  8.0     2.00  44.0     nan        True      mogi.D5_point   \n",
       "\n",
       "     polarity is_Observation_Of   size     has_Center  \n",
       "name                                                   \n",
       "D1       True       mogi.unit_x  13.79  mogi.D1_point  \n",
       "D2       True       mogi.unit_x  13.79  mogi.D2_point  \n",
       "D3       True       mogi.unit_x  13.79  mogi.D3_point  \n",
       "D4       True       mogi.unit_x  13.79  mogi.D4_point  \n",
       "D5       True       mogi.unit_x  13.79  mogi.D5_point  "
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:There isn't any coordinate column in the loaded dataset.\n",
      "Check the output and consider changing the separator with sep keyword or cahnge 'coordinate_label' parameter.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "too many indices for array: array is 1-dimensional, but 2 were indexed\n"
     ]
    }
   ],
   "source": [
    "# illustrates errors because of wrong separator\n",
    "try:\n",
    "    dataset2= load_dataset_from_csv(\"../inputs/data_for_paper.csv\", labels={\"ID\":\"Id\", \"strike\":\"dip_dir\",\"name\":\"observed_object\"})\n",
    "except Exception as e:\n",
    "    print(e)\n",
    "    gkf = GeologicalKnowledgeManager().get_knowledge_framework()\n",
    "    observations = gkf.search(type=gkf().PointBased_Observation)\n",
    "    gkf.remove_all_instances(observations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:There isn't any coordinate column in the loaded dataset.\n",
      "Check the output and consider changing the separator with sep keyword or cahnge 'coordinate_label' parameter.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GeologicalDataset.add_observation() got multiple values for argument 'name'\n"
     ]
    }
   ],
   "source": [
    "# illustrates errors when leaving wrong labels\n",
    "try:\n",
    "    dataset3 = load_dataset_from_csv(\"../inputs/data_for_paper.csv\", sep=\";\", index= \"ID\")\n",
    "except Exception as e:\n",
    "    print(e)\n",
    "    gkf = GeologicalKnowledgeManager().get_knowledge_framework()\n",
    "    observations = gkf.search(type=gkf().PointBased_Observation)\n",
    "    gkf.remove_all_instances(observations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manual creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>z</th>\n",
       "      <th>dip_dir</th>\n",
       "      <th>dip</th>\n",
       "      <th>observed_object</th>\n",
       "      <th>occurrence</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>D1</th>\n",
       "      <td>15.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>35.0</td>\n",
       "      <td>270.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>Trias_Base</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D2</th>\n",
       "      <td>30.0</td>\n",
       "      <td>25.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>270.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>Trias_Base</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D3</th>\n",
       "      <td>60.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>90.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>Trias_Base</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D4</th>\n",
       "      <td>75.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>25.0</td>\n",
       "      <td>90.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>Trias_Base</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D5</th>\n",
       "      <td>110.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>270.0</td>\n",
       "      <td>63.0</td>\n",
       "      <td>Trias_Base</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D6</th>\n",
       "      <td>120.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>60.0</td>\n",
       "      <td>270.0</td>\n",
       "      <td>64.0</td>\n",
       "      <td>Trias_Base</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D7</th>\n",
       "      <td>155.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>60.0</td>\n",
       "      <td>89.0</td>\n",
       "      <td>39.0</td>\n",
       "      <td>Trias_Base</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D8</th>\n",
       "      <td>190.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>91.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>Trias_Base</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D11</th>\n",
       "      <td>25.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>None</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D22</th>\n",
       "      <td>50.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>None</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D44</th>\n",
       "      <td>100.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>None</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D77</th>\n",
       "      <td>168.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>47.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>None</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          x     y     z  dip_dir   dip observed_object  occurrence\n",
       "name                                                              \n",
       "D1     15.0  20.0  35.0    270.0  45.0      Trias_Base        True\n",
       "D2     30.0  25.0  50.0    270.0  45.0      Trias_Base        True\n",
       "D3     60.0  30.0  40.0     90.0  45.0      Trias_Base        True\n",
       "D4     75.0  15.0  25.0     90.0  45.0      Trias_Base        True\n",
       "D5    110.0  20.0  40.0    270.0  63.0      Trias_Base        True\n",
       "D6    120.0  20.0  60.0    270.0  64.0      Trias_Base        True\n",
       "D7    155.0  20.0  60.0     89.0  39.0      Trias_Base        True\n",
       "D8    190.0  20.0  30.0     91.0  40.0      Trias_Base        True\n",
       "D11    25.0  22.0  45.0      NaN   NaN            None        True\n",
       "D22    50.0  22.0  50.0      NaN   NaN            None        True\n",
       "D44   100.0  30.0  20.0      NaN   NaN            None        True\n",
       "D77   168.0  30.0  47.0      NaN   NaN            None        True"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_head = np.array(['name', 'x', 'y', 'z', 'dip_dir', 'dip', 'observed_object','occurrence'])\n",
    "data_array = np.array([['D1', 15, 20, 35, 270, 45, 'Trias_Base',True],\n",
    "                       ['D2', 30, 25, 50, 270, 45, 'Trias_Base',True],\n",
    "                       ['D3', 60, 30, 40, 90, 45, 'Trias_Base',True],\n",
    "                       ['D4', 75, 15, 25, 90, 45, 'Trias_Base',True],\n",
    "                       ['D5', 110, 20, 40, 270, 63, 'Trias_Base',True],\n",
    "                       ['D6', 120, 20, 60, 270, 64, 'Trias_Base',True],\n",
    "                       ['D7', 155, 20, 60, 89, 39, 'Trias_Base',True],\n",
    "                       ['D8', 190, 20, 30, 91, 40, 'Trias_Base',True],\n",
    "                       ['D11', 25, 22, 45, np.nan, np.nan, None ,True],\n",
    "                       ['D22', 50, 22, 50, np.nan, np.nan, None,True],\n",
    "                       ['D44', 100, 30, 20, np.nan, np.nan, None,True],\n",
    "                       ['D77', 168, 30, 47, np.nan, np.nan, None,True]]\n",
    ")\n",
    "data_test = pd.DataFrame(data = data_array, columns = data_head)\n",
    "data_test = data_test.astype({'name':str, 'x':float, 'y':float, 'z':float, 'dip_dir':float, 'dip':float, 'observed_object':str, 'occurrence':bool})\n",
    "data_test.set_index(\"name\", inplace = True)\n",
    "data_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A dataset of type: GeologicalDataset\n",
      "- Size of dataset: 12\n",
      "- Types of data:\n",
      " |- occurrence:\t12 entries\n",
      " |- orientation:\t8 entries\n",
      "- Extension:\n",
      " |- Coord x: [15.0, 190.0]\n",
      " |- Coord y: [15.0, 30.0]\n",
      " |- Coord z: [20.0, 60.0]\n",
      "- Number of spaces this dataset is attached to: 1\n",
      " |- Physical space:Representation space of type: PhysicalRepresentationSpace\n",
      " | |- Number of dimension(s): 3\n",
      " | |- Coordinate label(s): ['x', 'y', 'z']\n",
      " | |- Space extension:\n",
      " | | |- Coord x: [-20. 225.]\n",
      " | | |- Coord y: [12. 33.]\n",
      " | | |- Coord z: [12. 68.]\n",
      " |- Temporal space: None\n"
     ]
    }
   ],
   "source": [
    "dataset = load_dataset_from_dataframe(data_test, coordinate_labels= [\"x\",\"y\",\"z\"])\n",
    "print(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>z</th>\n",
       "      <th>dip_dir</th>\n",
       "      <th>dip</th>\n",
       "      <th>geology</th>\n",
       "      <th>occurrence</th>\n",
       "      <th>has_Representation</th>\n",
       "      <th>polarity</th>\n",
       "      <th>is_Observation_Of</th>\n",
       "      <th>size</th>\n",
       "      <th>has_Center</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>D1</th>\n",
       "      <td>15.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>35.0</td>\n",
       "      <td>270.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D1_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D1_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D2</th>\n",
       "      <td>30.0</td>\n",
       "      <td>25.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>270.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D2_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D2_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D3</th>\n",
       "      <td>60.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>90.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D3_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D3_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D4</th>\n",
       "      <td>75.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>25.0</td>\n",
       "      <td>90.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D4_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D4_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D5</th>\n",
       "      <td>110.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>270.0</td>\n",
       "      <td>63.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D5_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D5_point</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          x     y     z  dip_dir   dip geology  occurrence has_Representation   \n",
       "name                                                                            \n",
       "D1     15.0  20.0  35.0    270.0  45.0     nan        True      mogi.D1_point  \\\n",
       "D2     30.0  25.0  50.0    270.0  45.0     nan        True      mogi.D2_point   \n",
       "D3     60.0  30.0  40.0     90.0  45.0     nan        True      mogi.D3_point   \n",
       "D4     75.0  15.0  25.0     90.0  45.0     nan        True      mogi.D4_point   \n",
       "D5    110.0  20.0  40.0    270.0  63.0     nan        True      mogi.D5_point   \n",
       "\n",
       "     polarity is_Observation_Of   size     has_Center  \n",
       "name                                                   \n",
       "D1       True   mogi.Trias_Base  12.25  mogi.D1_point  \n",
       "D2       True   mogi.Trias_Base  12.25  mogi.D2_point  \n",
       "D3       True   mogi.Trias_Base  12.25  mogi.D3_point  \n",
       "D4       True   mogi.Trias_Base  12.25  mogi.D4_point  \n",
       "D5       True   mogi.Trias_Base  12.25  mogi.D5_point  "
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "A dataset of type: GeologicalDataset<br>- Size of dataset: 12<br>- Types of data:<br> |- occurrence:\t12 entries<br> |- orientation:\t8 entries<br>- Extension:<br> |- Coord x: [15.0, 190.0]<br> |- Coord y: [15.0, 30.0]<br> |- Coord z: [20.0, 60.0]<br>- Number of spaces this dataset is attached to: 1<br> |- Physical space:Representation space of type: PhysicalRepresentationSpace<br> | |- Number of dimension(s): 3<br> | |- Coordinate label(s): ['x', 'y', 'z']<br> | |- Space extension:<br> | | |- Coord x: [-20. 225.]<br> | | |- Coord y: [12. 33.]<br> | | |- Coord z: [12. 68.]<br> |- Temporal space: None"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>z</th>\n",
       "      <th>dip_dir</th>\n",
       "      <th>dip</th>\n",
       "      <th>geology</th>\n",
       "      <th>occurrence</th>\n",
       "      <th>has_Representation</th>\n",
       "      <th>polarity</th>\n",
       "      <th>is_Observation_Of</th>\n",
       "      <th>size</th>\n",
       "      <th>has_Center</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>D1</th>\n",
       "      <td>15.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>35.0</td>\n",
       "      <td>270.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D1_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D1_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D2</th>\n",
       "      <td>30.0</td>\n",
       "      <td>25.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>270.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D2_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D2_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D3</th>\n",
       "      <td>60.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>90.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D3_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D3_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D4</th>\n",
       "      <td>75.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>25.0</td>\n",
       "      <td>90.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D4_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D4_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D5</th>\n",
       "      <td>110.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>270.0</td>\n",
       "      <td>63.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D5_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D5_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D6</th>\n",
       "      <td>120.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>60.0</td>\n",
       "      <td>270.0</td>\n",
       "      <td>64.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D6_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D6_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D7</th>\n",
       "      <td>155.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>60.0</td>\n",
       "      <td>89.0</td>\n",
       "      <td>39.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D7_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D7_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D8</th>\n",
       "      <td>190.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>91.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D8_point</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D8_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D11</th>\n",
       "      <td>25.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D11_point</td>\n",
       "      <td>NaN</td>\n",
       "      <td>mogi.None</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D11_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D22</th>\n",
       "      <td>50.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D22_point</td>\n",
       "      <td>NaN</td>\n",
       "      <td>mogi.None</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D22_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D44</th>\n",
       "      <td>100.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D44_point</td>\n",
       "      <td>NaN</td>\n",
       "      <td>mogi.None</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D44_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D77</th>\n",
       "      <td>168.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>47.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D77_point</td>\n",
       "      <td>NaN</td>\n",
       "      <td>mogi.None</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D77_point</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.display import display, HTML\n",
    "\n",
    "chart = HTML(dataset.info().replace(\"\\n\",\"<br>\"))\n",
    "display(chart)\n",
    "\n",
    "chart = HTML(dataset.to_dataframe().to_html())\n",
    "display(chart)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Testing interpretation from features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "* Owlready2 * Running HermiT...\n",
      "    java -Xmx2000M -cp c:\\Users\\glaurent\\Documents\\Outils\\Anaconda\\envs\\mogi\\lib\\site-packages\\owlready2\\hermit;c:\\Users\\glaurent\\Documents\\Outils\\Anaconda\\envs\\mogi\\lib\\site-packages\\owlready2\\hermit\\HermiT.jar org.semanticweb.HermiT.cli.CommandLine -c -O -D -I file:///C:/Users/glaurent/AppData/Local/Temp/tmp2xctt1xn\n",
      "* Owlready2 * HermiT took 0.8639678955078125 seconds\n",
      "* Owlready * (NB: only changes on entities loaded in Python are shown, other changes are done but not listed)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'mogi'"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "GeologicalKnowledgeManager().load_knowledge_framework()\n",
    "mogi = GeologicalKnowledgeManager().get_knowledge_framework()\n",
    "mogi.remove_all_instances()\n",
    "mogi.sync_reasoner()\n",
    "mogi.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A dataset of type: GeologicalDataset\n",
      "- Size of dataset: 12\n",
      "- Types of data:\n",
      " |- occurrence:\t12 entries\n",
      " |- orientation:\t8 entries\n",
      "- Extension:\n",
      " |- Coord x: [15.0, 190.0]\n",
      " |- Coord y: [15.0, 30.0]\n",
      " |- Coord z: [20.0, 60.0]\n",
      "- Number of spaces this dataset is attached to: 1\n",
      " |- Physical space:Representation space of type: PhysicalRepresentationSpace\n",
      " | |- Number of dimension(s): 3\n",
      " | |- Coordinate label(s): ['x', 'y', 'z']\n",
      " | |- Space extension:\n",
      " | | |- Coord x: [-20. 225.]\n",
      " | | |- Coord y: [12. 33.]\n",
      " | | |- Coord z: [12. 68.]\n",
      " |- Temporal space: None\n"
     ]
    }
   ],
   "source": [
    "data_head = np.array(['name', 'x', 'y', 'z', 'dip_dir', 'dip', 'observed_object','occurrence'])\n",
    "data_array = np.array([['D1', 15, 20, 35, 270, 45, 'Trias_Base',True],\n",
    "                       ['D2', 30, 25, 50, 270, 45, 'Trias_Base',True],\n",
    "                       ['D3', 60, 30, 40, 90, 45, 'Trias_Base',True],\n",
    "                       ['D4', 75, 15, 25, 90, 45, 'Trias_Base',True],\n",
    "                       ['D5', 110, 20, 40, 270, 63, 'Trias_Base',True],\n",
    "                       ['D6', 120, 20, 60, 270, 64, 'Trias_Base',True],\n",
    "                       ['D7', 155, 20, 60, 89, 39, 'Trias_Base',True],\n",
    "                       ['D8', 190, 20, 30, 91, 40, 'Trias_Base',True],\n",
    "                       ['D11', 25, 22, 45, np.nan, np.nan, None ,True],\n",
    "                       ['D22', 50, 22, 50, np.nan, np.nan, None,True],\n",
    "                       ['D44', 100, 30, 20, np.nan, np.nan, None,True],\n",
    "                       ['D77', 168, 30, 47, np.nan, np.nan, None,True]]\n",
    ")\n",
    "data_test = pd.DataFrame(data = data_array, columns = data_head)\n",
    "data_test = data_test.astype({'name':str, 'x':float, 'y':float, 'z':float, 'dip_dir':float, 'dip':float, 'observed_object':str, 'occurrence':bool})\n",
    "data_test.set_index(\"name\", inplace = True)\n",
    "dataset = load_dataset_from_dataframe(data_test, coordinate_labels= [\"x\",\"y\",\"z\"])\n",
    "print(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>z</th>\n",
       "      <th>dip_dir</th>\n",
       "      <th>dip</th>\n",
       "      <th>geology</th>\n",
       "      <th>occurrence</th>\n",
       "      <th>has_Representation</th>\n",
       "      <th>is_Observation_Of</th>\n",
       "      <th>polarity</th>\n",
       "      <th>size</th>\n",
       "      <th>has_Center</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>D1</th>\n",
       "      <td>15.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>35.0</td>\n",
       "      <td>270.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D1_point</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>True</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D1_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D2</th>\n",
       "      <td>30.0</td>\n",
       "      <td>25.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>270.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D2_point</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>True</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D2_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D3</th>\n",
       "      <td>60.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>90.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D3_point</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>True</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D3_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D4</th>\n",
       "      <td>75.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>25.0</td>\n",
       "      <td>90.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D4_point</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>True</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D4_point</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D5</th>\n",
       "      <td>110.0</td>\n",
       "      <td>20.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>270.0</td>\n",
       "      <td>63.0</td>\n",
       "      <td>nan</td>\n",
       "      <td>True</td>\n",
       "      <td>mogi.D5_point</td>\n",
       "      <td>mogi.Trias_Base</td>\n",
       "      <td>True</td>\n",
       "      <td>12.25</td>\n",
       "      <td>mogi.D5_point</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          x     y     z  dip_dir   dip geology  occurrence has_Representation  \\\n",
       "name                                                                            \n",
       "D1     15.0  20.0  35.0    270.0  45.0     nan        True      mogi.D1_point   \n",
       "D2     30.0  25.0  50.0    270.0  45.0     nan        True      mogi.D2_point   \n",
       "D3     60.0  30.0  40.0     90.0  45.0     nan        True      mogi.D3_point   \n",
       "D4     75.0  15.0  25.0     90.0  45.0     nan        True      mogi.D4_point   \n",
       "D5    110.0  20.0  40.0    270.0  63.0     nan        True      mogi.D5_point   \n",
       "\n",
       "     is_Observation_Of polarity   size     has_Center  \n",
       "name                                                   \n",
       "D1     mogi.Trias_Base     True  12.25  mogi.D1_point  \n",
       "D2     mogi.Trias_Base     True  12.25  mogi.D2_point  \n",
       "D3     mogi.Trias_Base     True  12.25  mogi.D3_point  \n",
       "D4     mogi.Trias_Base     True  12.25  mogi.D4_point  \n",
       "D5     mogi.Trias_Base     True  12.25  mogi.D5_point  "
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "instance: mogi.D1_point\n",
      "types: mogi.Point\n",
      "properties:\n",
      "|- has_Representation:[mogi.D1_point]\n",
      "|- coord3:[35.0]\n",
      "|- is_Representation_Of:[mogi.D1, mogi.D1_point]\n",
      "|- coord1:[15.0]\n",
      "|- coord3_label:['z']\n",
      "|- coord2:[20.0]\n",
      "|- coord1_label:['x']\n",
      "|- has_Center:[mogi.D1_point]\n",
      "|- coord2_label:['y']\n"
     ]
    }
   ],
   "source": [
    "mogi.show_instance_qualities(mogi().D1_point)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "section = AxisAlignedCrossSection(dataset.physical_space)\n",
    "section.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[mogi.D11 mogi.D1 mogi.D2]\n",
      "Number of instances: 3\n",
      "instance: mogi.D11\n",
      "types: mogi.PointBased_Observation\n",
      "properties:\n",
      "|- has_Representation:[mogi.D11_point]\n",
      "|- occurrence:[True]\n",
      "|- is_Observation_Of:[mogi.None]\n",
      "|- size:[12.25]\n",
      "|- has_Center:[mogi.D11_point]\n",
      "instance: mogi.D1\n",
      "types: mogi.PointBased_Observation\n",
      "properties:\n",
      "|- has_Representation:[mogi.D1_point]\n",
      "|- occurrence:[True]\n",
      "|- is_Observation_Of:[mogi.Trias_Base]\n",
      "|- dip_dir:[270.0]\n",
      "|- polarity:[True]\n",
      "|- size:[12.25]\n",
      "|- has_Center:[mogi.D1_point]\n",
      "|- dip:[45.0]\n",
      "instance: mogi.D2\n",
      "types: mogi.PointBased_Observation\n",
      "properties:\n",
      "|- has_Representation:[mogi.D2_point]\n",
      "|- occurrence:[True]\n",
      "|- is_Observation_Of:[mogi.Trias_Base]\n",
      "|- dip_dir:[270.0]\n",
      "|- polarity:[True]\n",
      "|- size:[12.25]\n",
      "|- has_Center:[mogi.D2_point]\n",
      "|- dip:[45.0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "situation = InterpretationSituation(\n",
    "    [mogi().D11, mogi().D1, mogi().D2]#, mogi().D4,mogi().D5, mogi().D3]\n",
    ")\n",
    "section.show()\n",
    "section.draw(situation)\n",
    "print(situation.features)\n",
    "mogi.show_all_instance_qualities(situation.features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "instance: mogi.interp_surf\n",
      "types: mogi.Stratigraphic_Part\n",
      "properties:\n",
      "|- has_Representation:[mogi.interp_surf_rep]\n",
      "|- explain:[mogi.D11, mogi.D1, mogi.D2]\n",
      "instance: mogi.interp_surf_rep\n",
      "types: mogi.Planar_Surface\n",
      "properties:\n",
      "|- has_Representation:[mogi.point115, mogi.point116, mogi.point117, mogi.point118]\n",
      "|- is_Representation_Of:[mogi.interp_surf]\n",
      "|- has_Center:[mogi.interp_surf_rep_center]\n",
      "|- has_Node2:[mogi.point117]\n",
      "|- has_Node3:[mogi.point118]\n",
      "|- dip_dir:[270.0]\n",
      "|- has_Node1:[mogi.point116]\n",
      "|- has_Normal:[mogi.interp_surf_rep_normal]\n",
      "|- polarity:[True]\n",
      "|- size:[40.248338626474556]\n",
      "|- has_Node0:[mogi.point115]\n",
      "|- dip:[45.0]\n",
      "instance: mogi.interp_surf_rep_center\n",
      "types: mogi.Point\n",
      "properties:\n",
      "|- has_Representation:[mogi.interp_surf_rep_center]\n",
      "|- coord3:[43.333333333333336]\n",
      "|- is_Representation_Of:[mogi.interp_surf_rep_center]\n",
      "|- coord1:[23.333333333333332]\n",
      "|- coord3_label:['z']\n",
      "|- coord2:[22.333333333333332]\n",
      "|- coord1_label:['x']\n",
      "|- has_Center:[mogi.interp_surf_rep_center]\n",
      "|- coord2_label:['y']\n",
      "Number of instances: 3\n",
      "instance: mogi.D11\n",
      "types: mogi.PointBased_Observation\n",
      "properties:\n",
      "|- has_Representation:[mogi.D11_point]\n",
      "|- occurrence:[True]\n",
      "|- is_Explained_By:[mogi.interp_surf]\n",
      "|- is_Observation_Of:[mogi.None]\n",
      "|- size:[12.25]\n",
      "|- has_Center:[mogi.D11_point]\n",
      "instance: mogi.D1\n",
      "types: mogi.PointBased_Observation\n",
      "properties:\n",
      "|- has_Representation:[mogi.D1_point]\n",
      "|- occurrence:[True]\n",
      "|- is_Explained_By:[mogi.interp_surf]\n",
      "|- is_Observation_Of:[mogi.Trias_Base]\n",
      "|- dip_dir:[270.0]\n",
      "|- polarity:[True]\n",
      "|- size:[12.25]\n",
      "|- has_Center:[mogi.D1_point]\n",
      "|- dip:[45.0]\n",
      "instance: mogi.D2\n",
      "types: mogi.PointBased_Observation\n",
      "properties:\n",
      "|- has_Representation:[mogi.D2_point]\n",
      "|- occurrence:[True]\n",
      "|- is_Explained_By:[mogi.interp_surf]\n",
      "|- is_Observation_Of:[mogi.Trias_Base]\n",
      "|- dip_dir:[270.0]\n",
      "|- polarity:[True]\n",
      "|- size:[12.25]\n",
      "|- has_Center:[mogi.D2_point]\n",
      "|- dip:[45.0]\n"
     ]
    }
   ],
   "source": [
    "interp = constructor_surface_part_from_interpretation(knowledge_framework= mogi, interpretation_situation= situation,\n",
    "                                             physical_space= dataset.physical_space, name= \"interp_surf\",extension_factor=0.15)\n",
    "mogi.show_instance_qualities(interp)\n",
    "mogi.show_instance_qualities(interp.has_Representation[0])\n",
    "mogi.show_instance_qualities(interp.has_Representation[0].has_Center[0])\n",
    "mogi.show_all_instance_qualities(interp.explain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "section = AxisAlignedCrossSection(dataset.physical_space)\n",
    "section.draw(situation)"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python",
   "pygments_lexer": "ipython3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}