Attempt to reproduce case study with old ragconnect 0.2.2

ros3rag.common/src/main/java/de/tudresden/inf/st/ros3rag/common/Util.java

@@ -81,6 +81,8 @@ public class Util {
   private final static Set<String> modules = new HashSet<>() {{
     add("ros3rag.placeA");
     add("ros3rag.placeB");
+    add("ros3rag.old.a");
+    add("ros3rag.old.b");
     add("ros3rag.common");
     add("ros3rag.coordinator");
   }};

ros3rag.common/src/main/resources/old-jastadd/types.connect

+ParseScene maps byte[] bytes to de.tudresden.inf.st.ceti.Scene {:
+  return de.tudresden.inf.st.ceti.Scene.parseFrom(bytes);
+:}
+
+ConvertScene maps de.tudresden.inf.st.ceti.Scene pbScene to Scene {:
+  var result = new Scene();
+  for (var pbObject : pbScene.getObjectsList()) {
+    ObjectOfInterest obj;
+    switch (pbObject.getType()) {
+      case BOX:
+        // BOX == MovableObject
+        MovableObject movableObject = new MovableObject();
+        result.addMovableObject(movableObject);
+        obj = movableObject;
+        break;
+      case DROP_OFF_LOCATION:
+        // DROP_OFF_LOCATION == DropOffLocation
+        DropOffLocation dropOffLocation = new DropOffLocation();
+        result.addDropOffLocation(dropOffLocation);
+        obj = dropOffLocation;
+        break;
+      case COLLABORATION_ZONE:
+        // COLLABORATION_ZONE == CollaborationZone
+        CollaborationZone cz = new CollaborationZone();
+        result.addDropOffLocation(cz);
+        obj = cz;
+        break;
+      case ARM:
+        // ARM == RobotObject
+        RobotObject ro = new RobotObject();
+        ro.setState(pbObject.getState());
+        result.addRobotObject(ro);
+        obj = ro;
+        break;
+      default:
+        // ignore object, continue for loop
+        continue;
+    }
+    obj.setName(pbObject.getId());
+
+    // position
+    var pos = new Position();
+    pos.setX(pbObject.getPos().getX());
+    pos.setY(pbObject.getPos().getY());
+    pos.setZ(pbObject.getPos().getZ());
+    obj.setPosition(pos);
+
+    // orientation
+    var orient = new Orientation();
+    orient.setX(pbObject.getOrientation().getX());
+    orient.setY(pbObject.getOrientation().getY());
+    orient.setZ(pbObject.getOrientation().getZ());
+    orient.setW(pbObject.getOrientation().getW());
+    obj.setOrientation(orient);
+
+    // size
+    var size = new Size();
+    size.setLength(pbObject.getSize().getLength());
+    size.setWidth(pbObject.getSize().getWidth());
+    size.setHeight(pbObject.getSize().getHeight());
+    obj.setSize(size);
+  }
+  return result;
+:}

ros3rag.common/src/main/resources/old-jastadd/types.jadd

+import org.apache.commons.math3.geometry.euclidean.threed.Rotation;
+import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
+import java.util.*;
+
+aspect Resolving {
+  //--- resolveObjectOfInterest ---
+  syn ObjectOfInterest Scene.resolveObjectOfInterest(String name) {
+    for (DropOffLocation location : getDropOffLocationList()) {
+      if (location.getName().equals(name)) {
+        return location;
+      }
+    }
+    for (MovableObject movableObject : getMovableObjectList()) {
+      if (movableObject.getName().equals(name)) {
+        return movableObject;
+      }
+    }
+    for (RobotObject robotObject : getRobotObjectList()) {
+      if (robotObject.getName().equals(name)) {
+        return robotObject;
+      }
+    }
+    return null;
+  }
+
+  //--- resolveLogicalObjectOfInterest ---
+  syn LogicalObjectOfInterest LogicalScene.resolveLogicalObjectOfInterest(String name) {
+    for (LogicalRegion region : getLogicalRegionList()) {
+      if (region.getName().equals(name)) {
+        return region;
+      }
+    }
+    for (LogicalMovableObject movableObject : getLogicalMovableObjectList()) {
+      if (movableObject.getName().equals(name)) {
+        return movableObject;
+      }
+    }
+    return null;
+  }
+
+  syn DropOffLocation LogicalMovableObject.myLocation() {
+    // classical reference attribute (was relation, but not allowed with RagConnect)
+    ObjectOfInterest obj = containingScene().resolveObjectOfInterest(getNameOfMyLocation());
+    return obj == null ? null : obj.asDropOffLocation();
+  }
+}
+
+aspect Computation {
+  //--- isLocatedAt ---
+  syn boolean MovableObject.isLocatedAt(DropOffLocation location) {
+    Orientation orient = location.getOrientation();
+    Position locationPosition = location.getPosition();
+    // true to do normalization, first parameter is scalar value
+    Rotation locationRotation = new Rotation(orient.getW(), orient.getX(), orient.getY(), orient.getZ(), true);
+
+    Position pos = this.getPosition();
+    // first do translation of objectVector to coordinate system of location
+    Vector3D objectVector = new Vector3D(pos.getX() - locationPosition.getX(),
+                                         pos.getY() - locationPosition.getY(),
+                                         pos.getZ() - locationPosition.getZ());
+
+    // apply rotation on this point
+    Vector3D rotatedObjectVector = locationRotation.applyInverseTo(objectVector);
+
+    // check whether coordinates are within the bounds of the given location
+    Size locationSize = location.getSize();
+    // we use half of the size of to the position as it is in the center of the location
+    double halfLocationLength = 0.5 * locationSize.getLength();
+    double halfLocationWidth = 0.5 * locationSize.getWidth();
+//    double halfLocationHeight = 0.5 * locationSize.getHeight();
+
+    double rotatedX = rotatedObjectVector.getX();
+    double rotatedY = rotatedObjectVector.getY();
+    double rotatedZ = rotatedObjectVector.getZ();
+
+//    System.out.printf("min: (%f , %f , %f). rotated: (%f , %f , %f), max: (%f , %f , %f)%n",
+//      -halfLocationLength, -halfLocationWidth, -halfLocationHeight,
+//      rotatedX, rotatedY, rotatedZ,
+//      halfLocationLength,
+//      halfLocationWidth,
+//      halfLocationHeight);
+
+    return  LT(-halfLocationLength, rotatedX) && LT(rotatedX, halfLocationLength) &&
+       LT(-halfLocationWidth, rotatedY) && LT(rotatedY, halfLocationWidth); // &&
+       //LT(-halfLocationHeight, rotatedZ) && LT(rotatedZ, halfLocationHeight);
+  }
+
+  syn MovableObject DropOffLocation.getObjectLocatedHere() {
+    for (MovableObject obj : containingScene().getMovableObjects()) {
+      if (obj.isLocatedAt(this)) {
+        return obj;
+      }
+    }
+    return null;
+  }
+
+  //--- getLogicalScene ---
+  syn LogicalScene Scene.getLogicalScene() {
+    var result = new LogicalScene();
+    Map<MovableObject, LogicalMovableObject> objects = new HashMap<>();
+    for (MovableObject movableObject : getMovableObjectList()) {
+      LogicalMovableObject newLogicalMovableObject = new LogicalMovableObject();
+      newLogicalMovableObject.setName(movableObject.getName());
+      result.addLogicalMovableObject(newLogicalMovableObject);
+      objects.put(movableObject, newLogicalMovableObject);
+    }
+    for (Region region : regionList()) {
+      LogicalRegion logicalRegion = new LogicalRegion();
+      logicalRegion.setName(region.getName());
+      result.addLogicalRegion(logicalRegion);
+      for (MovableObject movableObject : getMovableObjectList()) {
+        for (DropOffLocation location : region.locationList()) {
+          if (movableObject.isLocatedAt(location)) {
+            LogicalMovableObject logicalObject = objects.get(movableObject);
+            logicalRegion.addContainedObject(logicalObject);
+            logicalObject.setNameOfMyLocation(location.getName());
+          }
+        }
+      }
+    }
+    return result;
+  }
+
+  private static final double MovableObject.DELTA = 0.0001;
+
+  //--- LT ---
+  /**
+   * @return d1 <= d2 (within a DELTA)
+   */
+  private boolean MovableObject.LT(double d1, double d2) {
+    return org.apache.commons.math3.util.Precision.compareTo(d1, d2, DELTA) <= 0;
+  }
+}
+
+aspect Navigation {
+  // --- isDropOffLocation ---
+  syn boolean ObjectOfInterest.isDropOffLocation() = false;
+  eq DropOffLocation.isDropOffLocation() = true;
+
+  // --- asDropOffLocation ---
+  syn DropOffLocation ObjectOfInterest.asDropOffLocation() = null;
+  eq DropOffLocation.asDropOffLocation() = this;
+
+  // --- isRobotObject ---
+  syn boolean ObjectOfInterest.isRobotObject() = false;
+  eq RobotObject.isRobotObject() = true;
+
+  // --- asRobotObject ---
+  syn RobotObject ObjectOfInterest.asRobotObject() = null;
+  eq RobotObject.asRobotObject() = this;
+
+  // --- isLogicalRegion ---
+  syn boolean LogicalObjectOfInterest.isLogicalRegion() = false;
+  eq LogicalRegion.isLogicalRegion() = true;
+
+  // --- asLogicalRegion ---
+  syn LogicalRegion LogicalObjectOfInterest.asLogicalRegion() = null;
+  eq LogicalRegion.asLogicalRegion() = this;
+
+  // --- isLogicalMovableObject ---
+  syn boolean LogicalObjectOfInterest.isLogicalMovableObject() = false;
+  eq LogicalMovableObject.isLogicalMovableObject() = true;
+
+  // --- asLogicalMovableObject ---
+  syn LogicalMovableObject LogicalObjectOfInterest.asLogicalMovableObject() = null;
+  eq LogicalMovableObject.asLogicalMovableObject() = this;
+
+  inh Scene DropOffLocation.containingScene();
+  inh Scene MovableObject.containingScene();
+  inh Scene LogicalMovableObject.containingScene();
+  eq Scene.getChild().containingScene() = this;
+
+  syn boolean LogicalMovableObject.hasLocatedAt() = !getLocatedAtList().isEmpty();
+
+  // must be "implemented" in concrete world models, i.e., an equation must be defined
+  inh JastAddList<Region> Scene.regionList();
+
+  syn List<Region> DropOffLocation.containedInRegion() {
+    List<Region> result = new ArrayList<>();
+    for (Region region : containingScene().regionList()) {
+      List<String> locationNames = Arrays.asList(region.getLocationNames().split(","));
+      if (locationNames.contains(getName())) {
+        result.add(region);
+      }
+    }
+    return result;
+  }
+
+  protected static List<String> ASTNode.arrayAsList(String array) {
+    if (array == null || array.length() == 0) {
+      return new ArrayList<>();
+    }
+    return new ArrayList<>(Arrays.asList(array.split(",")));
+  }
+  syn List<String> Region.locationNamesAsList() = arrayAsList(getLocationNames()) ;
+  syn List<DropOffLocation> Region.locationList();
+
+  syn Set<String> LogicalMovableObject.regionNameSet() {
+    return getLocatedAtList().stream().map(LogicalRegion::getName).collect(java.util.stream.Collectors.toSet());
+  }
+}
+
+aspect Printing {
+  //--- prettyPrint ---
+  syn String JastAddList.prettyPrint() {
+    return prettyPrint(Object::toString);
+  }
+  syn String JastAddList.prettyPrint(java.util.function.Function<T, String> toString) {
+    return java.util.stream.StreamSupport.stream(Spliterators.spliteratorUnknownSize(this.iterator(), 16), false).map(toString::apply).collect(java.util.stream.Collectors.joining(", ", "[", "]"));
+  }
+
+  syn String Scene.prettyPrint() {
+    StringBuilder sb = new StringBuilder();
+    if (getNumDropOffLocation() == 0) {
+      sb.append(" no locations\n");
+    } else {
+      for (var location : getDropOffLocationList()) {
+        sb.append(" location ").append(location.prettyPrint()).append("\n");
+      }
+    }
+    if (getNumMovableObject() == 0) {
+      sb.append(" no objects\n");
+    } else {
+      for (var obj : getMovableObjectList()) {
+        sb.append(" obj ").append(obj.prettyPrint()).append("\n");
+      }
+    }
+    return sb.toString();
+  }
+
+  syn String MovableObject.prettyPrint() {
+    return "<obj " + nameAndHash() + getPosition().prettyPrint() + getOrientation().prettyPrint() + getSize().prettyPrint() + ">";
+  }
+
+  syn String DropOffLocation.prettyPrint() {
+    return "{" + printPrefix() + " " + getName() + getPosition().prettyPrint() + getOrientation().prettyPrint() + getSize().prettyPrint() + "}";
+  }
+
+  syn String DropOffLocation.printPrefix() = "loc";
+  eq CollaborationZone.printPrefix() = "CZ";
+
+  syn String Region.prettyPrint() {
+    return "{reg " + nameAndHash() + "}";
+  }
+
+  syn String Position.prettyPrint() {
+    return " pos=(" + getX() + "," + getY() + "," + getZ() + ")";
+  }
+
+  syn String Orientation.prettyPrint() {
+    return " orient=(" + getX() + "," + getY() + "," + getZ() + "," + getW() + ")";
+  }
+
+  syn String Size.prettyPrint() {
+    return " size=(" + getLength() + "," + getWidth() + "," + getHeight() + ")";
+  }
+
+  syn String LogicalScene.prettyPrint() {
+    StringBuilder sb = new StringBuilder();
+    if (getNumLogicalRegion() == 0) {
+      sb.append(" no region\n");
+    } else {
+      // TODO
+      for (LogicalRegion region : getLogicalRegionList()) {
+        sb.append(" region ").append(region.prettyPrint());
+        if (!region.getContainedObjectList().isEmpty()) {
+          sb.append(" (objects: ").append(region.getContainedObjectList().stream().map(LogicalMovableObject::getName).collect(java.util.stream.Collectors.joining(","))).append(")");
+        }
+        sb.append("\n");
+      }
+    }
+    if (getNumLogicalMovableObject() == 0) {
+      sb.append(" no objects\n");
+    } else {
+      for (LogicalMovableObject obj : getLogicalMovableObjectList()) {
+        sb.append(" obj ").append(obj.prettyPrint());
+        if (obj.hasLocatedAt()) {
+          sb.append(" (locatedAt: ").append(obj.getLocatedAtList().stream().map(LogicalRegion::nameAndHash).collect(java.util.stream.Collectors.joining(","))).append(")");
+        }
+        sb.append("\n");
+      }
+    }
+    return sb.toString();
+  }
+
+  syn String LogicalMovableObject.prettyPrint() {
+    return  "<lObj " + nameAndHash() + ">";
+  }
+  syn String LogicalRegion.prettyPrint() {
+    return "{lReg " + nameAndHash() + "}";
+  }
+
+  syn String LogicalObjectOfInterest.nameAndHash() = getName() + "@" + Integer.toHexString(hashCode());
+  syn String ObjectOfInterest.nameAndHash() = getName() + "@" + Integer.toHexString(hashCode());
+  syn String Region.nameAndHash() = getName() + "@" + Integer.toHexString(hashCode());
+}
+
+aspect ConvenienceMethods {
+  // --- of ---
+  public static DropOffLocation DropOffLocation.of(String name,
+        Position position, Orientation orientation, Size size) {
+    var location = new DropOffLocation();
+    initObjectOfInterest(location, name, position, orientation, size);
+    return location;
+  }
+
+  public static MovableObject MovableObject.of(String name, Position position) {
+    var location = new MovableObject();
+    initObjectOfInterest(location, name, position,
+        Orientation.of(0, 0, 0, 0), Size.of(0, 0, 0));
+    return location;
+  }
+
+  protected static void ObjectOfInterest.initObjectOfInterest(ObjectOfInterest object, String name,
+        Position position, Orientation orientation, Size size) {
+    object.setName(name);
+    object.setPosition(position);
+    object.setOrientation(orientation);
+    object.setSize(size);
+  }
+
+  public static Position Position.of(double x, double y, double z) {
+    return new Position(x, y, z);
+  }
+
+  public static Orientation Orientation.of(double x, double y, double z, double w) {
+    return new Orientation(x, y, z, w);
+  }
+
+  public static Size Size.of(double length, double width, double height) {
+    return new Size(length, width, height);
+  }
+}
+
+aspect Glue {
+  class MqttHandler implements de.tudresden.inf.st.ros3rag.common.SharedMainParts.MqttHandlerWrapper<MqttHandler> {}
+}

ros3rag.common/src/main/resources/old-jastadd/types.relast

+Position ::= <X:double> <Y:double> <Z:double> ;
+Size ::= <Length:double> <Width:double> <Height:double> ;
+Orientation ::= <X:double> <Y:double> <Z:double> <W:double> ;
+
+// Regions cannot be contained in scene, but must be retrieved via attribute
+Scene ::= DropOffLocation* MovableObject* RobotObject* /LogicalScene/ ;
+
+ObjectOfInterest ::= <Name:String> Position Size Orientation ;
+
+DropOffLocation : ObjectOfInterest ;
+MovableObject : ObjectOfInterest ;
+RobotObject : ObjectOfInterest ::= <State:de.tudresden.inf.st.ceti.Object.State> ;
+
+LogicalScene ::= LogicalRegion* LogicalMovableObject* ;
+LogicalObjectOfInterest ::= <Name:String> ;
+LogicalRegion : LogicalObjectOfInterest ;
+LogicalMovableObject : LogicalObjectOfInterest ::= <NameOfMyLocation> ;
+rel LogicalRegion.ContainedObject* <-> LogicalMovableObject.LocatedAt* ;
+
+// could lead to problems when including this information and sending it
+//rel LogicalMovableObject.MyLocation? -> DropOffLocation ;
+
+Region ::= <Name:String> <LocationNames> ;
+//rel Region.Location* <-> DropOffLocation.ContainedInRegion* ;
+
+// only used in site-B, but needed here for parsing the scene
+CollaborationZone : DropOffLocation ;

ros3rag.common/src/main/resources/tasks.gradle

-// setting default value
+// setting default values
 try {
     project.ext.ragConnectProtocols
 } catch(ignored) {
     project.ext.ragConnectProtocols = 'mqtt'
 }
+try {
+    project.ext.useOldRagConnect
+} catch(ignored) {
+    project.ext.useOldRagConnect = false
+}
 
 dependencies {
     jastadd2 "org.jastadd:jastadd2:2.3.5-dresden-6"
@@ -42,6 +47,28 @@ task ragConnect(type: JavaExec) {
 
 }
 
+task mergeFilesForOldRagConnect {
+    mkdir 'src/gen/workaround/'
+    (file('src/gen/workaround/merged.relast')).text = file(project.ext.ragConnectInputGrammar).getText() + new File(file(project.ext.sharedJastAddDir), 'types.relast').getText()
+    (file('src/gen/workaround/merged.connect')).text = file(project.ext.ragConnectInputConnect).getText() + new File(file(project.ext.sharedJastAddDir), 'types.connect').getText()
+}
+
+task oldRagConnect(type: JavaExec) {
+    group = 'Build'
+    main = '-jar'
+
+    args([
+            '../libs/ragconnect-0.2.2.jar',
+//            '--verbose',
+            '--o=src/gen/jastadd',
+            file('src/gen/workaround/merged.relast'),
+            file('src/gen/workaround/merged.connect'),
+            '--rootNode=' + project.ext.ragConnectRootNode,
+            '--protocols=' + project.ext.ragConnectProtocols,
+            '--List=JastAddList'
+    ])
+}
+
 // Input files for relast
 //def relastFiles = ["src/gen/jastadd/MinimalModel.relast", "src/gen/jastadd/RagConnect.relast"]
 
@@ -50,8 +77,7 @@ task grammar2uml(type: JavaExec) {
     classpath = configurations.grammar2uml
 
     args([
-            '--verbose',
-            'src/gen/jastadd/types.relast'
+            '--verbose'
     ] + project.ext.relastFiles)
 }
 
@@ -73,11 +99,10 @@ task relastToJastAdd(type: JavaExec) {
           "--jastAddList=JastAddList",
           "--serializer=jackson",
           "--resolverHelper",
-          "--file",
-          "src/gen/jastadd/types.relast"
+          "--file"
     ] + project.ext.relastFiles
 
-    inputs.files project.ext.relastFiles + ['src/gen/jastadd/types.relast']
+    inputs.files project.ext.relastFiles
     outputs.files file("./src/gen/jastadd/model.ast"), file("./src/gen/jastadd/model.jadd")
 }
 
@@ -127,7 +152,11 @@ jastadd {
 
     // jastaddOptions = ["--lineColumnNumbers", "--visitCheck=true", "--rewrite=cnta", "--cache=all"]
     // default options are: '--rewrite=cnta', '--safeLazy', '--visitCheck=false', '--cacheCycle=false'
-    extraJastAddOptions = [
+    extraJastAddOptions = project.ext.useOldRagConnect ? [
+            '--lineColumnNumbers',
+            '--List=JastAddList',
+    ] :
+    [
             '--lineColumnNumbers',
             '--List=JastAddList',
             '--cache=all',
@@ -143,4 +172,9 @@ cleanGen.doFirst {
 
 // Workflow configuration for phases
 generateAst.dependsOn relastToJastAdd
+if (project.ext.useOldRagConnect) {
+    oldRagConnect.dependsOn mergeFilesForOldRagConnect
+    relastToJastAdd.dependsOn oldRagConnect
+} else {
     relastToJastAdd.dependsOn ragConnect
+}

ros3rag.old.a/.gitignore

+build
+src/gen-res/
+src/gen/
+out/
+*.class

ros3rag.old.a/build.gradle

+buildscript {
+    repositories.mavenCentral()
+    dependencies {
+        classpath group: 'org.jastadd', name: 'jastaddgradle', version: "${jastadd_gradle_version}"
+    }
+}
+
+plugins {
+    id 'ros3rag.java-application-conventions'
+    id 'ros3rag.java-old-ragconnect-conventions'
+}
+
+mainClassName = 'de.tudresden.inf.st.old.a.OldMainA'
+
+task simpleRun(type: JavaExec) {
+    group 'application'
+    classpath sourceSets.main.runtimeClasspath
+    main = "de.tudresden.inf.st.old.a.OldSimpleMainA"
+
+}
+
+dependencies {
+    implementation project(':ros3rag.common')
+}
+
+ext.sharedJastAddDir = 'src/main/jastadd/old-shared'
+ext.ragConnectInputGrammar = 'src/main/jastadd/OldWorldModelA.relast'
+ext.ragConnectInputConnect = 'src/main/jastadd/OldWorldModelA.connect'
+ext.ragConnectRootNode = 'ArtificialRoot'
+ext.relastFiles = ["src/gen/jastadd/merged.relast", "src/gen/jastadd/RagConnect.relast"]
+ext.jastaddAstPackage = 'de.tudresden.inf.st.old.a.ast'
+ext.useOldRagConnect = true
+
+apply from: '../ros3rag.common/src/main/resources/tasks.gradle'

ros3rag.old.a/src/main/jastadd/Additional.jadd

+aspect NewComputationNeededForOldRagConnect {
+  syn String WorldModelA.getLogicalSceneAsNtaToken() {
+    // copied from placeA/src/gen/jastadd/RagConnect.jadd -> ASTNode._ragconnect__apply__TreeDefaultLogicalSceneToBytesMapping(LogicalScene input)
+    java.io.ByteArrayOutputStream outputStream = new java.io.ByteArrayOutputStream();
+  com.fasterxml.jackson.core.JsonFactory factory = new com.fasterxml.jackson.core.JsonFactory();
+  try {
+    com.fasterxml.jackson.core.JsonGenerator generator = factory.createGenerator(outputStream, com.fasterxml.jackson.core.JsonEncoding.UTF8);
+    getLogicalScene().serialize(generator);
+    generator.flush();
+  } catch (IOException | SerializationException e) {
+    e.printStackTrace();
+    return null;
+  }
+  return outputStream.toString();
+  }
+}

ros3rag.old.a/src/main/jastadd/OldWorldModelA.connect

+// --- receiving ---
+//receive WorldModelA.Scene using ParseScene, ConvertScene ;
+
+// --- sending ---
+send WorldModelA.LogicalSceneAsNtaToken ;
+
+// probably need dependency definitions?

ros3rag.old.a/src/main/jastadd/OldWorldModelA.jadd

+aspect Navigation {
+  //--- worldModelA ---
+  inh WorldModelA ASTNode.worldModelA();
+  eq WorldModelA.getChild().worldModelA() = this;
+}
+
+aspect Glue {
+  class ArtificialRoot implements de.tudresden.inf.st.ros3rag.common.SharedMainParts.WorldModelWrapper {}
+
+  //--- getLogicalScene ---
+  syn LogicalScene WorldModelA.getLogicalScene() = hasScene() ? getScene().getLogicalScene() : new LogicalScene();
+
+  eq WorldModelA.getScene().regionList() = getRegionList();
+  eq Region.locationList() {
+    List<DropOffLocation> result = new ArrayList<>();
+    if (!worldModelA().hasScene()) { return result; }
+    for (String locationName : locationNamesAsList()) {
+      result.add(worldModelA().getScene().resolveObjectOfInterest(locationName).asDropOffLocation());
+    }
+    return result;
+  }
+}

ros3rag.old.a/src/main/jastadd/OldWorldModelA.relast

+ArtificialRoot ::= WorldModelA ;
+
+WorldModelA ::= Region* [Scene] /LogicalScene/ /<LogicalSceneAsNtaToken>/ ;

ros3rag.old.a/src/main/jastadd/forwardsComp.jadd

+aspect BackwardsCompatibility {
+  public void ArtificialRoot.ragconnectCheckIncremental() {
+    // empty by definition (no incremental evaluation)
+  }
+}

ros3rag.old.a/src/main/jastadd/old-shared

+../../../../ros3rag.common/src/main/resources/old-jastadd
\ No newline at end of file

ros3rag.old.a/src/main/java/de/tudresden/inf/st/old/a/OldMainA.java

+package de.tudresden.inf.st.old.a;
+
+import de.tudresden.inf.st.old.a.ast.ArtificialRoot;
+import de.tudresden.inf.st.old.a.ast.MqttHandler;
+import de.tudresden.inf.st.old.a.ast.Scene;
+import de.tudresden.inf.st.old.a.ast.WorldModelA;
+import de.tudresden.inf.st.ros3rag.common.SharedMainParts;
+import de.tudresden.inf.st.ros3rag.common.Util;
+
+import java.io.File;
+import java.io.IOException;
+
+import static de.tudresden.inf.st.ros3rag.common.Util.mqttUri;
+import static de.tudresden.inf.st.ros3rag.common.Util.readScene;
+
+/**
+ * Entry point for RAG model in place A.
+ *
+ * @author rschoene - Initial contribution
+ */
+public class OldMainA extends SharedMainParts<MqttHandler, ArtificialRoot> {
+  private final String TOPIC_SCENE_UPDATE_FROM_ROS;
+  private final String TOPIC_SCENE_UPDATE_TO_PLACE_B;
+
+  private final String TOPIC_DEMO_MOVE_objectRed1_BLUE;
+  private final String TOPIC_DEMO_MOVE_objectRed1_RED;
+  private final String TOPIC_EVAL_MOVE;
+
+  OldMainA(String configFile) {
+    super("place-a", OldUtilA.pathToDirectoryOfPlaceA().resolve(configFile));
+    this.TOPIC_SCENE_UPDATE_FROM_ROS = cellName + "/scene/update";
+    this.TOPIC_SCENE_UPDATE_TO_PLACE_B = cellName + "/logical/update";
+
+    this.TOPIC_DEMO_MOVE_objectRed1_BLUE = cellName + "/demo/move/objectRed1/blue";
+    this.TOPIC_DEMO_MOVE_objectRed1_RED = cellName + "/demo/move/objectRed1/red";
+    this.TOPIC_EVAL_MOVE = cellName + "/eval/move";
+  }
+
+  public static void main(String[] args) throws Exception {
+    String configFile = args.length == 0 ? "src/main/resources/config-a.yaml" : args[0];
+    new OldMainA(configFile).run();
+  }
+
+  @Override
+  protected MqttHandler createMqttHandler() {
+    return new MqttHandler("mainHandlerA");
+  }
+
+  @Override
+  protected void createSpecificMainHandlerConnections() {
+    mainHandler.newConnection(TOPIC_DEMO_MOVE_objectRed1_BLUE, bytes ->
+        OldUtilA.updatePositionOfObjectToLocation(model.getWorldModelA().getScene(), "objectRed1", "binBlue")
+    );
+    mainHandler.newConnection(TOPIC_DEMO_MOVE_objectRed1_RED, bytes ->
+        OldUtilA.updatePositionOfObjectToLocation(model.getWorldModelA().getScene(), "objectRed1", "binRed")
+    );
+    mainHandler.newConnection(TOPIC_EVAL_MOVE, bytes -> {
+        String[] tokens = new String(bytes).split(" to ");
+        String objectName = tokens[0];
+        String locationName = tokens[1];
+        OldUtilA.updatePositionOfObjectToLocation(model.getWorldModelA().getScene(), objectName, locationName);
+    });
+  }
+
+  @Override
+  protected ArtificialRoot createWorldModel() throws Exception {
+    de.tudresden.inf.st.ceti.Scene scene = readScene(
+        OldUtilA.pathToDirectoryOfPlaceA().resolve(config.forA.filenameInitialScene)
+    );
+    Scene myScene = OldUtilA.convert(scene);
+    WorldModelA worldModel = new WorldModelA().setScene(myScene);
+    return new ArtificialRoot().setWorldModelA(worldModel);
+  }
+
+  @Override
+  protected void readInitialConfigs() throws IOException {
+    // read and set regions
+    File regionFile = OldUtilA.pathToDirectoryOfPlaceA().resolve(config.filenameRegions).toFile();
+    OldUtilA.setRegions(model.getWorldModelA(), Util.parseRegionConfig(regionFile));
+
+    // no robots to be set
+  }
+
+  @Override
+  protected void connectEndpoints() throws IOException {
+//    model.connectScene(mqttUri(TOPIC_SCENE_UPDATE_FROM_ROS, config));
+    model.getWorldModelA().connectLogicalSceneAsNtaToken(mqttUri(TOPIC_SCENE_UPDATE_TO_PLACE_B, config), true);
+  }
+
+  @Override
+  protected String getModelInfos(ArtificialRoot artificialRoot, boolean detailed) {
+    return OldUtilA.getModelInfos(artificialRoot.getWorldModelA(), detailed);
+  }
+}

ros3rag.old.a/src/main/java/de/tudresden/inf/st/old/a/OldSimpleMainA.java

+package de.tudresden.inf.st.old.a;
+
+import de.tudresden.inf.st.old.a.ast.*;
+import org.apache.commons.math3.geometry.euclidean.threed.Rotation;
+import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Scanner;
+import java.util.concurrent.TimeUnit;
+
+import static de.tudresden.inf.st.ros3rag.common.Util.readScene;
+
+/**
+ * Testing features for placeA.
+ *
+ * @author rschoene - Initial contribution
+ */
+public class OldSimpleMainA {
+  private static final Logger logger = LogManager.getLogger(OldSimpleMainA.class);
+
+  @SuppressWarnings("CommentedOutCode")
+  public static void main(String[] args) throws Exception {
+//    testLocatedAt();
+//    testBuildModelA();
+    testReadSceneConfig();
+  }
+
+  @SuppressWarnings("CommentedOutCode")
+  private static void testReadSceneConfig() throws Exception {
+    final var path = OldUtilA.pathToDirectoryOfPlaceA().resolve("src/main/resources/config-scene-a.json");
+    de.tudresden.inf.st.ceti.Scene scene = readScene(path);
+    Scene myScene = OldUtilA.convert(scene);
+
+    ArtificialRoot root = new ArtificialRoot();
+
+    WorldModelA model = new WorldModelA();
+    model.setScene(myScene);
+    root.setWorldModelA(model);
+
+    // send initial scene once
+//    MqttHandler publisher = new MqttHandler().dontSendWelcomeMessage().setHost("localhost");
+//    publisher.publish("scene/init", scene.toByteArray());
+    logger.fatal("Skipping publishing to scene/init for now");
+
+    root.ragconnectCheckIncremental();
+    root.ragconnectSetupMqttWaitUntilReady(2, TimeUnit.SECONDS);
+
+//    model.connectScene("mqtt://localhost/scene/update");
+    model.connectLogicalSceneAsNtaToken("mqtt://localhost/logical/scene/update", true);
+  }
+
+  @SuppressWarnings("unused")
+  private static void testBuildModelA() {
+    WorldModelA model = new WorldModelA();
+
+    // scene
+    var scene = new Scene();
+    model.setScene(scene);
+    scene.addMovableObject(MovableObject.of("obj1", Position.of(1, 2, 3)));
+    scene.addDropOffLocation(DropOffLocation.of("placeAlfa",
+        Position.of(0, 0, 0),
+        Orientation.of(0, 0, 0, 1),
+        Size.of(1, 1, 1)));
+    scene.addDropOffLocation(DropOffLocation.of("placeBeta",
+        Position.of(1, 1, 1),
+        Orientation.of(0, 0, 0, 1),
+        Size.of(1, 1, 1)));
+    scene.addDropOffLocation(DropOffLocation.of("placeGamma",
+        Position.of(2, 2, 2),
+        Orientation.of(0, 0, 0, 1),
+        Size.of(2, 2, 2)));
+    logger.info("obj1 at gamma: {}",
+        scene.getMovableObject(0).isLocatedAt(scene.getDropOffLocation(2)));
+
+    // check logical scene
+    var logicalScene = scene.getLogicalScene();
+    logger.info("logicalScene:\n{}", logicalScene.prettyPrint());
+  }
+
+  @SuppressWarnings("unused")
+  private static void testLocatedAt() {
+    Rotation r = new Rotation(0, 0, 1, 0, false);
+    Vector3D v = new Vector3D(1, 2, 3);
+    r.applyTo(v);
+
+    var modelA = new WorldModelA();
+    var sceneA = new Scene();
+    modelA.setScene(sceneA);
+
+    // rotate bin2 by 90°, so width and height should effectively be swapped afterwards
+    Vector3D start = new Vector3D(1, 0, 0);
+    Vector3D end = new Vector3D(0, 0, 1);
+    Rotation rot = new Rotation(start, end);
+
+    DropOffLocation bin1 = DropOffLocation.of("Bin1",
+        Position.of(1, 1, 1),
+        Orientation.of(0, 0, 0, 1),
+        Size.of(2, 3, 4));
+    DropOffLocation bin2 = DropOffLocation.of("Bin2",
+        Position.of(1, 1, 1),
+        Orientation.of((float) rot.getQ1(), (float) rot.getQ2(), (float) rot.getQ3(), (float) rot.getQ0()),
+        Size.of(2, 3, 4));
+    MovableObject objectA = MovableObject.of("ObjectA",
+        Position.of(0, 0, 0));
+    MovableObject objectB = MovableObject.of("ObjectB",
+        Position.of(1, 1, 1));
+    sceneA.addDropOffLocation(bin1)
+        .addMovableObject(objectA)
+        .addMovableObject(objectB);
+
+    /*
+     0.0 <= x <= 2.0
+    -0.5 <= y <= 2.5
+    -1.0 <= z <= 3.0
+     */
+
+    logger.info("ObjectA locatedAt Bin1: {}", objectA.isLocatedAt(bin1));
+    logger.info("ObjectB locatedAt Bin1: {}", objectB.isLocatedAt(bin1));
+    logger.info("ObjectA locatedAt Bin2: {}", objectA.isLocatedAt(bin2));
+    logger.info("ObjectB locatedAt Bin2: {}", objectB.isLocatedAt(bin2));
+    Scanner scanner = new Scanner(System.in);
+    while (true) {
+      try {
+        System.out.print("x: ");
+        float x = scanner.nextFloat();
+        System.out.print("y: ");
+        float y = scanner.nextFloat();
+        System.out.print("z: ");
+        float z = scanner.nextFloat();
+        MovableObject object = MovableObject.of("temp", Position.of(x, y, z));
+        System.out.println("located at Bin2? : " + object.isLocatedAt(bin2));
+      } catch (Exception e) {
+        break;
+      }
+    }
+  }
+}

ros3rag.old.a/src/main/java/de/tudresden/inf/st/old/a/OldUtilA.java

+package de.tudresden.inf.st.old.a;
+
+import de.tudresden.inf.st.old.a.ast.*;
+import de.tudresden.inf.st.ros3rag.common.RegionConfiguration;
+import de.tudresden.inf.st.ros3rag.common.RegionConfiguration.RegionDefinition;
+import de.tudresden.inf.st.ros3rag.common.Util;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.nio.file.Path;
+
+/**
+ * Static utility methods used only for place A.
+ *
+ * @author rschoene - Initial contribution
+ */
+public class OldUtilA {
+  private static final Logger logger = LogManager.getLogger(OldUtilA.class);
+
+  static Path pathToDirectoryOfPlaceA() {
+    return Util.pathToModuleDirectory("ros3rag.old.a");
+  }
+
+  static Scene convert(de.tudresden.inf.st.ceti.Scene scene) throws Exception {
+    return new ExposingASTNode().exposed_apply_ConvertScene(scene);
+  }
+
+  static void setRegions(WorldModelA model, RegionConfiguration config) {
+    JastAddList<Region> result = new JastAddList<>();
+    for (RegionDefinition def : config.regions) {
+      Region region = new Region();
+      region.setName(def.name);
+      region.setLocationNames(String.join(",", def.positions));
+      result.add(region);
+    }
+    model.setRegionList(result);
+  }
+
+  static void updatePositionOfObjectToLocation(Scene scene, String objName, String locationName) {
+    ObjectOfInterest obj = scene.resolveObjectOfInterest(objName);
+    ObjectOfInterest location = scene.resolveObjectOfInterest(locationName);
+    if (obj != null && location != null) {
+      // move objectRed1 to binBlue
+      logger.info("Got " + obj + " and location " + location);
+      logger.debug("before to {} at {}\n{}", locationName, location.getPosition(),
+          scene.prettyPrint());
+
+      obj.setPosition(Position.of(location.getPosition().getX(),
+          location.getPosition().getY(),
+          location.getPosition().getZ()));
+
+      logger.debug("after\n{}", scene.prettyPrint());
+    } else {
+      logger.error("Obj (" + obj + ") or location (" + location + ") are null");
+    }
+  }
+
+  public static String getModelInfos(WorldModelA model, boolean detailed) {
+    StringBuilder sb = new StringBuilder();
+    if (detailed) {
+      // also include "normal" scene
+      sb.append("myScene:");
+      if (model.hasScene()) {
+        sb.append("\n").append(model.getScene().prettyPrint());
+      } else {
+        sb.append(" (unset)\n");
+      }
+    }
+    sb.append("myLogicalScene:");
+    if (model.hasScene()) {
+      sb.append("\n").append(model.getScene().getLogicalScene().prettyPrint());
+    } else {
+      sb.append(" (unset)\n");
+    }
+    return sb.toString();
+  }
+
+  @SuppressWarnings("rawtypes")
+  static class ExposingASTNode extends ASTNode {
+    public Scene exposed_apply_ConvertScene(de.tudresden.inf.st.ceti.Scene pbScene) throws Exception {
+      return _apply_ConvertScene(pbScene);
+    }
+  }
+}

ros3rag.old.a/src/main/resources

+../../../ros3rag.placeA/src/main/resources
\ No newline at end of file

ros3rag.old.b/.gitignore

+build
+src/gen-res/
+src/gen/
+out/
+*.class
+images/

ros3rag.old.b/build.gradle

+buildscript {
+    repositories.mavenLocal()
+    repositories.mavenCentral()
+    dependencies {
+        classpath group: 'org.jastadd', name: 'jastaddgradle', version: "${jastadd_gradle_version}"
+    }
+}
+
+plugins {
+    id 'ros3rag.java-application-conventions'
+    id 'ros3rag.java-old-ragconnect-conventions'
+}
+
+mainClassName = 'de.tudresden.inf.st.old.b.OldMainB'
+
+task simpleRun(type: JavaExec) {
+    group 'application'
+    classpath sourceSets.main.runtimeClasspath
+    main = "de.tudresden.inf.st.old.b.OldSimpleMainB"
+    standardInput = System.in
+}
+
+dependencies {
+    implementation project(':ros3rag.common')
+    testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter-params', version: "${jupiter_version}"
+}
+
+ext.sharedJastAddDir = 'src/main/jastadd/old-shared'
+ext.ragConnectInputGrammar = 'src/main/jastadd/OldWorldModelB.relast'
+ext.ragConnectInputConnect = 'src/main/jastadd/OldWorldModelB.connect'
+ext.ragConnectRootNode = 'ArtificialRoot'
+ext.relastFiles = ["src/gen/jastadd/merged.relast", "src/main/jastadd/BFS/BFS.relast", "src/main/jastadd/OldRobotReachabilityToBFS.relast", "src/gen/jastadd/RagConnect.relast"]
+ext.jastaddAstPackage = 'de.tudresden.inf.st.old.b.ast'
+ext.useOldRagConnect = true
+
+apply from: '../ros3rag.common/src/main/resources/tasks.gradle'