Merge branch 'main' of github.com:cram2/semantic_world into world-copy

Author: Tigul

examples/persistence_of_annotated_worlds.md

@@ -54,7 +54,7 @@ world = URDFParser.from_file(table).parse()
 Next, we create a semantic annotation that describes the table.
 
 ```{code-cell} ipython3
-table_semantic_annotation = Table([b for b in world.bodies if "top" in str(b.name)][0])
+table_semantic_annotation = Table(body=[b for b in world.bodies if "top" in str(b.name)][0])
 with world.modify_world():
     world.add_semantic_annotation(table_semantic_annotation)
 print(table_semantic_annotation)

scripts/create_postgres_database_and_user_if_not_exists.sql

@@ -0,0 +1,34 @@
+-- create_postgres_database_and_user_if_not_exists.sql (PostgreSQL, idempotent, psql-compatible)
+-- Usage (as postgres superuser):
+--   sudo -u postgres psql -f create_postgres_database_and_user_if_not_exists.sql \
+--        -v db_name="semantic_digital_twin" \
+--        -v user_name="semantic_digital_twin" \
+--        -v user_password="a_strong_password_here"
+
+-- 1) Create database if it does not exist (PostgreSQL has no CREATE DATABASE IF NOT EXISTS)
+SELECT 'CREATE DATABASE ' || quote_ident(:'db_name')
+WHERE NOT EXISTS (
+  SELECT FROM pg_database WHERE datname = :'db_name'
+)\gexec
+
+-- 2) Create role (user) if it does not exist
+SELECT format('CREATE ROLE %I LOGIN PASSWORD %L', :'user_name', :'user_password')
+WHERE NOT EXISTS (
+  SELECT FROM pg_roles WHERE rolname = :'user_name'
+)\gexec
+
+-- 3) Make that role the owner of the database
+ALTER DATABASE :"db_name" OWNER TO :"user_name";
+
+-- 4) Connect to the target database as current superuser (not the new user),
+--    so we can set permissions and default privileges inside that database
+\c :"db_name"
+
+-- 5) Grant privileges on the public schema to the application role
+GRANT ALL ON SCHEMA public TO :"user_name";
+
+-- 6) Ensure future objects get privileges automatically
+--    Use FOR ROLE to set defaults owned by the application role
+ALTER DEFAULT PRIVILEGES FOR ROLE :"user_name" IN SCHEMA public GRANT ALL ON TABLES TO :"user_name";
+ALTER DEFAULT PRIVILEGES FOR ROLE :"user_name" IN SCHEMA public GRANT ALL ON SEQUENCES TO :"user_name";
+ALTER DEFAULT PRIVILEGES FOR ROLE :"user_name" IN SCHEMA public GRANT ALL ON FUNCTIONS TO :"user_name";

scripts/generate_orm.py

@@ -10,41 +10,41 @@
 import os
 from dataclasses import is_dataclass
 
-import krrood.entity_query_language.orm.model
 import trimesh
 from krrood.class_diagrams import ClassDiagram
-from krrood.entity_query_language.predicate import HasTypes, HasType, Symbol
-from krrood.entity_query_language.symbol_graph import SymbolGraph
 from krrood.ormatic.dao import AlternativeMapping
 from krrood.ormatic.ormatic import ORMatic
 from krrood.ormatic.utils import classes_of_module
 from krrood.utils import recursive_subclasses
 
 import semantic_digital_twin.orm.model
+import semantic_digital_twin.reasoning.predicates
 import semantic_digital_twin.robots.abstract_robot
 import semantic_digital_twin.semantic_annotations.semantic_annotations
 import semantic_digital_twin.world  # ensure the module attribute exists on the package
+import semantic_digital_twin.adapters.procthor.procthor_semantic_annotations
 import semantic_digital_twin.world_description.degree_of_freedom
 import semantic_digital_twin.world_description.geometry
 import semantic_digital_twin.world_description.shape_collection
 import semantic_digital_twin.world_description.world_entity
 from semantic_digital_twin.datastructures.prefixed_name import PrefixedName
+from semantic_digital_twin.reasoning.predicates import ContainsType
+from semantic_digital_twin.semantic_annotations.mixins import HasBody
 from semantic_digital_twin.spatial_computations.forward_kinematics import (
     ForwardKinematicsManager,
 )
 from semantic_digital_twin.world import (
     ResetStateContextManager,
     WorldModelUpdateContextManager,
 )
+from semantic_digital_twin.world import WorldModelManager
 from semantic_digital_twin.world_description.connections import (
     FixedConnection,
     HasUpdateState,
 )
+from semantic_digital_twin.orm.model import *  # type: ignore
 
-
-# collect all semantic digital twin classes that should be mapped
-all_classes = set(classes_of_module(semantic_digital_twin.orm.model))
-all_classes |= set(
+all_classes = set(
     classes_of_module(semantic_digital_twin.world_description.world_entity)
 )
 all_classes |= set(classes_of_module(semantic_digital_twin.world_description.geometry))
@@ -66,6 +66,15 @@
     classes_of_module(semantic_digital_twin.world_description.degree_of_freedom)
 )
 all_classes |= set(classes_of_module(semantic_digital_twin.robots.abstract_robot))
+# classes |= set(recursive_subclasses(ViewFactory))
+all_classes |= set([HasBody] + recursive_subclasses(HasBody))
+all_classes |= set(classes_of_module(semantic_digital_twin.reasoning.predicates))
+all_classes |= set(classes_of_module(semantic_digital_twin.semantic_annotations.mixins))
+all_classes |= set(
+    classes_of_module(
+        semantic_digital_twin.adapters.procthor.procthor_semantic_annotations
+    )
+)
 
 
 # remove classes that should not be mapped
@@ -74,29 +83,22 @@
     WorldModelUpdateContextManager,
     HasUpdateState,
     ForwardKinematicsManager,
+    WorldModelManager,
+    semantic_digital_twin.adapters.procthor.procthor_semantic_annotations.ProcthorResolver,
+    ContainsType,
 }
-
-# build the symbol graph
-symbol_graph = SymbolGraph()
-
-# collect all KRROOD classes
-all_classes |= {c.clazz for c in symbol_graph.class_diagram.wrapped_classes}
-all_classes |= {am.original_class() for am in recursive_subclasses(AlternativeMapping)}
-all_classes |= set(classes_of_module(krrood.entity_query_language.symbol_graph))
-all_classes |= {Symbol}
-
-# remove classes that don't need persistence
-all_classes -= {HasType, HasTypes}
-
-
 # keep only dataclasses that are NOT AlternativeMapping subclasses
 all_classes = {
     c for c in all_classes if is_dataclass(c) and not issubclass(c, AlternativeMapping)
 }
-
-# ensure we have the original classes of the mappings (ORMatic uses these)
 all_classes |= {am.original_class() for am in recursive_subclasses(AlternativeMapping)}
 
+alternative_mappings = [
+    am
+    for am in recursive_subclasses(AlternativeMapping)
+    if am.original_class() in all_classes
+]
+
 
 def generate_orm():
     """
@@ -109,7 +111,7 @@ def generate_orm():
     instance = ORMatic(
         class_dependency_graph=class_diagram,
         type_mappings={trimesh.Trimesh: semantic_digital_twin.orm.model.TrimeshType},
-        alternative_mappings=recursive_subclasses(AlternativeMapping),
+        alternative_mappings=alternative_mappings,
     )
 
     instance.make_all_tables()

scripts/parse_procthor_files_and_save_to_database.py

@@ -6,27 +6,36 @@
 from typing import List
 
 import tqdm
+from krrood.entity_query_language.symbol_graph import SymbolGraph
 from krrood.ormatic.dao import to_dao
 from krrood.ormatic.utils import drop_database
+from krrood.utils import recursive_subclasses
 from sqlalchemy import create_engine
 from sqlalchemy.orm import Session
 from typing_extensions import TYPE_CHECKING
 
+
+from semantic_digital_twin.world import World
+
+sg = SymbolGraph()
+
+
 from semantic_digital_twin.adapters.fbx import FBXParser
 from semantic_digital_twin.adapters.procthor.procthor_pipelines import (
     dresser_factory_from_body,
 )
 from semantic_digital_twin.orm.ormatic_interface import *
+from semantic_digital_twin.adapters.procthor.procthor_semantic_annotations import (
+    ProcthorResolver,
+)
+from semantic_digital_twin.semantic_annotations.mixins import HasBody
 from semantic_digital_twin.pipeline.pipeline import (
     Pipeline,
     BodyFilter,
     BodyFactoryReplace,
     CenterLocalGeometryAndPreserveWorldPose,
 )
 
-if TYPE_CHECKING:
-    from semantic_digital_twin.world import World
-
 
 def remove_root_and_move_children_into_new_worlds(world: World) -> List[World]:
     """
@@ -48,8 +57,10 @@ def remove_root_and_move_children_into_new_worlds(world: World) -> List[World]:
 
     with world.modify_world():
 
-        worlds = [world.copy_subgraph_to_new_world(child) for child in root_children]
+        worlds = [world.move_branch_to_new_world(child) for child in root_children]
         for world in worlds:
+            if world.root is None:
+                ...
             world.name = world.root.name.name
 
     return worlds
@@ -102,6 +113,12 @@ def parse_fbx_file_to_world_mapping_daos(fbx_file_path: str) -> List[WorldMappin
     worlds = remove_root_and_move_children_into_new_worlds(world)
 
     worlds = replace_dresser_meshes_with_factories(worlds, dresser_pattern)
+    resolver = ProcthorResolver(*[recursive_subclasses(HasBody)])
+    for world in worlds:
+        resolved = resolver.resolve(world.name)
+        if resolved:
+            with world.modify_world():
+                world.add_semantic_annotation(resolved(body=world.root))
 
     return [to_dao(world) for world in worlds]
 
@@ -116,11 +133,11 @@ def parse_procthor_files_and_save_to_database(
     TODO: Ensure all relevant files, even those not inside a grp, are parsed.
     """
     semantic_digital_twin_database_uri = os.environ.get(
-        "semantic_digital_twin_DATABASE_URI"
+        "SEMANTIC_DIGITAL_TWIN_DATABASE_URI"
     )
     assert (
         semantic_digital_twin_database_uri is not None
-    ), "Please set the semantic_digital_twin_DATABASE_URI environment variable."
+    ), "Please set the SEMANTIC_DIGITAL_TWIN_DATABASE_URI environment variable."
 
     procthor_root = os.path.join(os.path.expanduser("~"), "ai2thor")
     # procthor_root = os.path.join(os.path.expanduser("~"), "work", "ai2thor")
@@ -147,7 +164,7 @@ def parse_procthor_files_and_save_to_database(
         if not any([e in f for e in excluded_words]) and fbx_file_pattern.fullmatch(f)
     ]
     # Create database engine and session
-    engine = create_engine(f"mysql+pymysql://{semantic_digital_twin_database_uri}")
+    engine = create_engine(semantic_digital_twin_database_uri)
     session = Session(engine)
 
     if drop_existing_database:

scripts/parse_procthor_worlds_and_calculate_containment_ratio.py

@@ -0,0 +1,95 @@
+import itertools
+import logging
+import os
+
+import prior
+import tqdm
+from krrood.entity_query_language.symbol_graph import SymbolGraph
+from krrood.ormatic.dao import to_dao, ToDAOState
+from krrood.ormatic.utils import classes_of_module, drop_database
+from krrood.utils import recursive_subclasses
+from sqlalchemy import create_engine
+from sqlalchemy.orm import Session
+
+import semantic_digital_twin.adapters.procthor.procthor_semantic_annotations
+from semantic_digital_twin.adapters.procthor.procthor_parser import ProcTHORParser
+from semantic_digital_twin.adapters.procthor.procthor_semantic_annotations import (
+    ProcthorResolver,
+)
+from semantic_digital_twin.semantic_annotations.mixins import HasBody
+from semantic_digital_twin.reasoning.predicates import InsideOf
+from semantic_digital_twin.orm.ormatic_interface import *
+from semantic_digital_twin.world_description.world_entity import SemanticAnnotation
+
+
+def parse_procthor_worlds_and_calculate_containment_ratio():
+    semantic_world_database_uri = os.environ.get("SEMANTIC_DIGITAL_TWIN_DATABASE_URI")
+    semantic_world_engine = create_engine(semantic_world_database_uri, echo=False)
+    semantic_world_session = Session(semantic_world_engine)
+
+    procthor_experiments_database_uri = os.environ.get(
+        "PROCTHOR_EXPERIMENTS_DATABASE_URI"
+    )
+    procthor_experiments_engine = create_engine(
+        procthor_experiments_database_uri, echo=False
+    )
+    # drop_database(procthor_experiments_engine)
+    # Base.metadata.create_all(procthor_experiments_engine)
+    procthor_experiments_session = Session(procthor_experiments_engine)
+
+    dataset = prior.load_dataset("procthor-10k")
+
+    # Iterate through all JSON files in the directory
+    for index, house in enumerate(
+        tqdm.tqdm(dataset["train"], desc="Parsing Procthor worlds")
+    ):
+        if index < 5058:
+            continue
+        try:
+            parser = ProcTHORParser(f"house_{index}", house, semantic_world_session)
+            world = parser.parse()
+        except Exception as e:
+            logging.error(f"Error parsing house {index}: {e}")
+            continue
+        # resolve views
+        resolver = ProcthorResolver(
+            [
+                cls
+                for cls in classes_of_module(
+                    semantic_digital_twin.adapters.procthor.procthor_semantic_annotations
+                )
+                if issubclass(cls, SemanticAnnotation)
+            ]
+        )
+        for body in world.bodies:
+            resolved = resolver.resolve(body.name.name)
+            if resolved:
+                with world.modify_world():
+                    world.add_semantic_annotation(
+                        resolved(body=body), skip_duplicates=True
+                    )
+
+        state = ToDAOState()
+        daos = []
+
+        world_dao = to_dao(world, state=state)
+        procthor_experiments_session.add(world_dao)
+
+        for kse, other in itertools.product(
+            world.kinematic_structure_entities, world.kinematic_structure_entities
+        ):
+            if kse != other:
+                is_inside = InsideOf(kse, other)
+                if is_inside() > 0.0:
+                    dao = to_dao(is_inside, state=state)
+                    daos.append(dao)
+
+        procthor_experiments_session.add_all(daos)
+        procthor_experiments_session.commit()
+        procthor_experiments_session.expunge_all()
+        semantic_world_session.expunge_all()
+        SymbolGraph().clear()
+
+
+if __name__ == "__main__":
+    parse_procthor_worlds_and_calculate_containment_ratio()