org.simantics.g3d/src/org/simantics/proconf/g3d/base/G3DTools.java

   1 /*******************************************************************************\r
   2  * Copyright (c) 2007- VTT Technical Research Centre of Finland.\r
   3  * All rights reserved. This program and the accompanying materials\r
   4  * are made available under the terms of the Eclipse Public License v1.0\r
   5  * which accompanies this distribution, and is available at\r
   6  * http://www.eclipse.org/legal/epl-v10.html\r
   7  *\r
   8  * Contributors:\r
   9  *     VTT Technical Research Centre of Finland - initial API and implementation\r
  10  *******************************************************************************/\r
  11 package org.simantics.proconf.g3d.base;\r
  12 \r
  13 import java.util.Collection;\r
  14 import java.util.Set;\r
  15 import java.util.Stack;\r
  16 \r
  17 import javax.vecmath.AxisAngle4d;\r
  18 import javax.vecmath.AxisAngle4f;\r
  19 import javax.vecmath.Point3d;\r
  20 import javax.vecmath.Point3f;\r
  21 import javax.vecmath.Quat4d;\r
  22 import javax.vecmath.Tuple3d;\r
  23 import javax.vecmath.Tuple3f;\r
  24 import javax.vecmath.Vector3d;\r
  25 import javax.vecmath.Vector3f;\r
  26 \r
  27 import org.simantics.db.Builtins;\r
  28 import org.simantics.db.Graph;\r
  29 import org.simantics.db.Resource;\r
  30 import org.simantics.layer0.utils.Statement;\r
  31 import org.simantics.layer0.utils.IEntity;\r
  32 import org.simantics.layer0.utils.EntityFactory;\r
  33 import org.simantics.layer0.utils.viewpoints.State;\r
  34 import org.simantics.layer0.utils.viewpoints.TraversalDecision;\r
  35 import org.simantics.layer0.utils.viewpoints.TraversalResult;\r
  36 import org.simantics.layer0.utils.viewpoints.TraversalRule;\r
  37 import org.simantics.layer0.utils.viewpoints.TraversalUtils;\r
  38 import org.simantics.proconf.g3d.Resources;\r
  39 import org.simantics.proconf.g3d.stubs.G3DNode;\r
  40 import org.simantics.proconf.g3d.stubs.Orientation;\r
  41 import org.simantics.proconf.g3d.stubs.Position;\r
  42 \r
  43 /**\r
  44  * Basic ThreeDimensionalModelingOntology tools\r
  45  * \r
  46  * @author Marko Luukkainen\r
  47  *\r
  48  */\r
  49 public class G3DTools {\r
  50         \r
  51         private static boolean DEBUG = false;\r
  52         \r
  53         private static TransformationTools tt;\r
  54 \r
  55         public static void initialize() {\r
  56                 tt = new TransformationTools(Resources.g3dResource.HasChild, Resources.g3dResource.HasParent);\r
  57         }\r
  58         \r
  59         public static void deinitialize() {\r
  60                 tt = null;\r
  61         }\r
  62         \r
  63         public static Point3d getPoint(IEntity p) {\r
  64         return new Point3d(p.getSingleRelatedScalarDouble(Resources.g3dResource.HasX),\r
  65                                            p.getSingleRelatedScalarDouble(Resources.g3dResource.HasY),\r
  66                                            p.getSingleRelatedScalarDouble(Resources.g3dResource.HasZ));\r
  67     }\r
  68     \r
  69     public static Point3f getPointFloat(IEntity p) {\r
  70         return new Point3f((float)p.getSingleRelatedScalarDouble(Resources.g3dResource.HasX),\r
  71                                            (float)p.getSingleRelatedScalarDouble(Resources.g3dResource.HasY),\r
  72                                            (float)p.getSingleRelatedScalarDouble(Resources.g3dResource.HasZ));\r
  73     }\r
  74     \r
  75     \r
  76     public static Vector3d getVector(IEntity p) {\r
  77         return new Vector3d(p.getSingleRelatedScalarDouble(Resources.g3dResource.HasX),\r
  78                                                         p.getSingleRelatedScalarDouble(Resources.g3dResource.HasY),\r
  79                                                         p.getSingleRelatedScalarDouble(Resources.g3dResource.HasZ));\r
  80     }\r
  81     \r
  82     public static Vector3f getVectorFloat(IEntity p) {\r
  83         return new Vector3f((float)p.getSingleRelatedScalarDouble(Resources.g3dResource.HasX),\r
  84                                                         (float)p.getSingleRelatedScalarDouble(Resources.g3dResource.HasY),\r
  85                                                         (float)p.getSingleRelatedScalarDouble(Resources.g3dResource.HasZ));\r
  86     }\r
  87 \r
  88     \r
  89     public static void setTuple3(IEntity d, Tuple3d translation) {\r
  90         d.setRelatedScalarDouble(Resources.g3dResource.HasX, translation.x);\r
  91         d.setRelatedScalarDouble(Resources.g3dResource.HasY, translation.y);\r
  92         d.setRelatedScalarDouble(Resources.g3dResource.HasZ, translation.z);    \r
  93     }\r
  94     \r
  95     public static void setTuple3(IEntity d, Tuple3f translation) {\r
  96         d.setRelatedScalarDouble(Resources.g3dResource.HasX, translation.x);\r
  97         d.setRelatedScalarDouble(Resources.g3dResource.HasY, translation.y);\r
  98         d.setRelatedScalarDouble(Resources.g3dResource.HasZ, translation.z);    \r
  99     }\r
 100 \r
 101     public static void setTuple3(IEntity d, double x, double y, double z) {\r
 102         d.setRelatedScalarDouble(Resources.g3dResource.HasX, x);\r
 103         d.setRelatedScalarDouble(Resources.g3dResource.HasY, y);\r
 104         d.setRelatedScalarDouble(Resources.g3dResource.HasZ, z);    \r
 105     }\r
 106     \r
 107     public static void addTuple3(IEntity d, Tuple3d translation) {\r
 108         d.setRelatedScalarDouble(Resources.g3dResource.HasX, translation.x + d.getSingleRelatedScalarDouble(Resources.g3dResource.HasX));\r
 109         d.setRelatedScalarDouble(Resources.g3dResource.HasY, translation.y + d.getSingleRelatedScalarDouble(Resources.g3dResource.HasY));\r
 110         d.setRelatedScalarDouble(Resources.g3dResource.HasZ, translation.z + d.getSingleRelatedScalarDouble(Resources.g3dResource.HasZ));\r
 111     }\r
 112     \r
 113     public static void addTuple3(IEntity d, Tuple3f translation) {\r
 114         d.setRelatedScalarDouble(Resources.g3dResource.HasX, translation.x + d.getSingleRelatedScalarDouble(Resources.g3dResource.HasX));\r
 115         d.setRelatedScalarDouble(Resources.g3dResource.HasY, translation.y + d.getSingleRelatedScalarDouble(Resources.g3dResource.HasY));\r
 116         d.setRelatedScalarDouble(Resources.g3dResource.HasZ, translation.z + d.getSingleRelatedScalarDouble(Resources.g3dResource.HasZ));\r
 117     }\r
 118 \r
 119     public static void addTuple3(IEntity d, double x, double y, double z) {\r
 120         d.setRelatedScalarDouble(Resources.g3dResource.HasX, x + d.getSingleRelatedScalarDouble(Resources.g3dResource.HasX));\r
 121         d.setRelatedScalarDouble(Resources.g3dResource.HasY, y + d.getSingleRelatedScalarDouble(Resources.g3dResource.HasY));\r
 122         d.setRelatedScalarDouble(Resources.g3dResource.HasZ, z + d.getSingleRelatedScalarDouble(Resources.g3dResource.HasZ));    \r
 123     }\r
 124     \r
 125     public static AxisAngle4d getOrientation(IEntity r) {\r
 126         return new AxisAngle4d(r.getSingleRelatedScalarDouble(Resources.g3dResource.HasX),\r
 127                                                    r.getSingleRelatedScalarDouble(Resources.g3dResource.HasY),\r
 128                                                    r.getSingleRelatedScalarDouble(Resources.g3dResource.HasZ),\r
 129                                                    r.getSingleRelatedScalarDouble(Resources.g3dResource.HasAngle));\r
 130     }\r
 131     \r
 132     public static AxisAngle4f getOrientationFloat(IEntity r) {\r
 133         return new AxisAngle4f((float)r.getSingleRelatedScalarDouble(Resources.g3dResource.HasX),\r
 134                                            (float)r.getSingleRelatedScalarDouble(Resources.g3dResource.HasY),\r
 135                                            (float)r.getSingleRelatedScalarDouble(Resources.g3dResource.HasZ),\r
 136                                            (float)r.getSingleRelatedScalarDouble(Resources.g3dResource.HasAngle));\r
 137     }\r
 138 \r
 139     public static void setOrientation(IEntity r, AxisAngle4d aa) {\r
 140         r.setRelatedScalarDouble(Resources.g3dResource.HasX, aa.x);\r
 141         r.setRelatedScalarDouble(Resources.g3dResource.HasY, aa.y);\r
 142         r.setRelatedScalarDouble(Resources.g3dResource.HasZ, aa.z);\r
 143         r.setRelatedScalarDouble(Resources.g3dResource.HasAngle, aa.angle);\r
 144     }\r
 145     \r
 146     \r
 147     public static void multiplyOrientation(IEntity r, AxisAngle4d rot) {\r
 148                 AxisAngle4d current = getOrientation(r);\r
 149                 Quat4d q1 = new Quat4d();\r
 150                 q1.set(current);\r
 151                 Quat4d q2 = new Quat4d();\r
 152                 // q2.set(rot);\r
 153                 q2.set(rot);\r
 154                 q2.mul(q1);\r
 155                 rot.set(q2);\r
 156                 setOrientation(r, rot);\r
 157         }\r
 158     \r
 159     \r
 160     public static AxisAngle4d getWorldFromLocal(IEntity node, AxisAngle4d localRot) {\r
 161         return tt.getWorldFromLocal(node, localRot);\r
 162     }\r
 163     \r
 164     public static Point3d getWorldFromLocal(IEntity node, Point3d localRot) {\r
 165         return tt.getWorldFromLocal(node, localRot);\r
 166     }\r
 167     \r
 168     public static AxisAngle4d getLocalFromWorld(IEntity node, AxisAngle4d localRot) {\r
 169         return tt.getLocalFromWorld(node, localRot);\r
 170     }\r
 171     \r
 172     public static Point3d getLocalFromWorld(IEntity node, Point3d localRot) {\r
 173         return tt.getLocalFromWorld(node, localRot);\r
 174     }\r
 175     \r
 176     public static void propagateLocalTransformChange(IEntity node, IEntity child) {\r
 177         tt.propagateLocalTransformChange(node, child);\r
 178     }\r
 179     \r
 180     public static void propagateWorldTransformChange(IEntity node, IEntity child) {\r
 181         tt.propagateWorldTransformChange(node, child);\r
 182     }\r
 183     \r
 184     public static void transformationUpdate(Graph graph, Resource resource) {\r
 185         tt.transformationUpdate(graph, resource);\r
 186     }\r
 187     \r
 188     public static void resetTransformation(IEntity shape) {\r
 189                 Graph graph = shape.getGraph();\r
 190                 if (shape.getAtMostOneRelatedObject(Resources.g3dResource.HasLocalPosition) == null) {\r
 191 \r
 192                         // LocalPosition p = LocalPosition.createDefault(graph);\r
 193                         Position p = Position.createDefault(graph);\r
 194                         shape.addStatement(Resources.g3dResource.HasLocalPosition, p);\r
 195                         // WorldPosition p2 = WorldPosition.createDefault(graph);\r
 196                         Position p2 = Position.createDefault(graph);\r
 197                         shape.addStatement(Resources.g3dResource.HasWorldPosition, p2);\r
 198                         p.setX(new double[] { 0.0 });\r
 199                         p.setY(new double[] { 0.0 });\r
 200                         p.setZ(new double[] { 0.0 });\r
 201 \r
 202                         p2.setX(new double[] { 0.0 });\r
 203                         p2.setY(new double[] { 0.0 });\r
 204                         p2.setZ(new double[] { 0.0 });\r
 205 \r
 206                 } else {\r
 207                         G3DTools.setTuple3(shape.getSingleRelatedObject(Resources.g3dResource.HasLocalPosition), 0.0, 0.0, 0.0);\r
 208                         G3DTools.setTuple3(shape.getSingleRelatedObject(Resources.g3dResource.HasWorldPosition), 0.0, 0.0, 0.0);\r
 209                 }\r
 210                 if (shape.getAtMostOneRelatedObject(Resources.g3dResource.HasLocalOrientation) == null) {\r
 211 \r
 212                         // LocalOrientation r = LocalOrientationFactory.create(graph);\r
 213                         Orientation r = Orientation.createDefault(graph);\r
 214                         shape.addStatement(Resources.g3dResource.HasLocalOrientation, r);\r
 215                         // WorldOrientation r2 = WorldOrientationFactory.create(graph);\r
 216                         Orientation r2 = Orientation.createDefault(graph);\r
 217                         shape.addStatement(Resources.g3dResource.HasWorldOrientation, r2);\r
 218                         r.setAngle(new double[] { 0.0 });\r
 219                         r.setX(new double[] { 1.0 });\r
 220                         r.setY(new double[] { 0.0 });\r
 221                         r.setZ(new double[] { 0.0 });\r
 222                         r2.setAngle(new double[] { 0.0 });\r
 223                         r2.setX(new double[] { 1.0 });\r
 224                         r2.setY(new double[] { 0.0 });\r
 225                         r2.setZ(new double[] { 0.0 });\r
 226 \r
 227                 } else {\r
 228                         G3DTools.setOrientation(shape.getSingleRelatedObject(Resources.g3dResource.HasLocalOrientation),\r
 229                                         new AxisAngle4d(0.0, 1.0, 0.0, 0.0));\r
 230                         G3DTools.setOrientation(shape.getSingleRelatedObject(Resources.g3dResource.HasWorldOrientation),\r
 231                                         new AxisAngle4d(0.0, 1.0, 0.0, 0.0));\r
 232                 }\r
 233         }\r
 234     \r
 235     \r
 236     public static G3DNode getModelFromResource(Graph graph,Resource resource) {\r
 237         G3DNode node = new G3DNode(graph, resource);\r
 238         while (true) {\r
 239                 G3DNode parent = node.getParent();\r
 240                 if (parent == null)\r
 241                         break;\r
 242                 node = parent;\r
 243         }\r
 244         return node;\r
 245     }\r
 246     \r
 247     /**\r
 248      * Checks if instance has a certain property instance\r
 249      * @param instance\r
 250      * @param propertyInstance\r
 251      * @return\r
 252      */\r
 253     public static boolean hasProperty(Graph graph,Resource instance, Resource propertyInstance) {\r
 254         Builtins builtins = graph.getBuiltins();\r
 255         Stack<IEntity> props = new Stack<IEntity>();\r
 256         IEntity IEntity = EntityFactory.create(graph, instance);\r
 257         Collection<IEntity> res = IEntity.getRelatedObjects(builtins.HasProperty);\r
 258         for (IEntity t : res)\r
 259                 props.add(t);\r
 260         \r
 261         while (!props.isEmpty()) {\r
 262             IEntity property = props.pop();\r
 263             if (property.getResource().equals(propertyInstance)) {\r
 264                 return true;\r
 265             }\r
 266             res = property.getRelatedObjects(builtins.HasProperty);\r
 267             for (IEntity r : res) {\r
 268                 props.add(r);\r
 269             }\r
 270         }\r
 271         return false;\r
 272     }\r
 273     \r
 274     /**\r
 275      * Checks if one of shapes subshapes has a certain property\r
 276      * @param instance shape instance\r
 277      * @param propertyInstance instance of a property\r
 278      * @return\r
 279      * \r
 280      */\r
 281     public static boolean hasSubProperty(Graph graph,Resource instance, Resource propertyInstance) {\r
 282          Builtins builtins = graph.getBuiltins();\r
 283          Stack<IEntity> instances = new Stack<IEntity>();\r
 284 \r
 285          //Resource res[] = instance.getRelatedResources(Builtins.HasProperty);\r
 286          IEntity entity = EntityFactory.create(graph, instance);\r
 287          Collection<IEntity> res;\r
 288 //         res = entity.getRelatedObjects(Resources.g3dResource.HasChild);\r
 289 //         for (IEntity t : res) {\r
 290 //               Collection<IEntity> sub = t.getRelatedObjects(Resources.g3dResource.HasGeometryDefinition);\r
 291 //               if (sub.size() > 0)\r
 292 //              instances.addAll(sub);\r
 293 //         }\r
 294          {\r
 295                  Collection<IEntity> sub = entity.getRelatedObjects(Resources.g3dResource.HasGeometryDefinition);\r
 296                  if (sub.size() > 0)\r
 297                 instances.addAll(sub);\r
 298          }\r
 299          while (!instances.isEmpty()) {\r
 300             IEntity i = instances.pop();\r
 301             Stack<IEntity> props = new Stack<IEntity>();\r
 302             res = i.getRelatedObjects(builtins.HasProperty);\r
 303             for (IEntity r : res) {\r
 304                 props.add(r);\r
 305             }\r
 306             while (!props.isEmpty()) {\r
 307                 IEntity property = props.pop();\r
 308                 if (property.equals(propertyInstance)) {\r
 309                     return true;\r
 310                 }\r
 311                 res = property.getRelatedObjects(builtins.HasProperty);\r
 312                 for (IEntity r : res) {\r
 313                     props.add(r);\r
 314                 }\r
 315             }\r
 316             res = i.getRelatedObjects(Resources.g3dResource.HasGeometryDefinition);\r
 317             for (IEntity r : res) {\r
 318                 // TODO : unnecessary check\r
 319                 Collection<IEntity> sub = r.getRelatedObjects(Resources.g3dResource.GeometryDefinitionOf);\r
 320                         if (sub.size() > 0)\r
 321                         instances.add(r);\r
 322             }\r
 323             \r
 324         }\r
 325          return false;\r
 326      }\r
 327     \r
 328     \r
 329     \r
 330     \r
 331     \r
 332     \r
 333     /**\r
 334      * Loads positions of control point to rule cache\r
 335      * \r
 336      * @param root resource of the modeled plant\r
 337      */\r
 338     public static void reloadCache(Graph graph, Resource root) {\r
 339 //        TraverseHandler handler = new TraverseHandler() {\r
 340 //            public boolean addToResult(Resource r) {\r
 341 //                if (r.isInstanceOf(GlobalIdMap.get(ThreeDimensionalModelingOntologyMapping.GRAPHICS_NODE)))\r
 342 //                    return true;\r
 343 //                return false;\r
 344 //            }\r
 345 //            \r
 346 //            public TraverseRelation[] traverseFromResource(Resource resource) {\r
 347 //                return new TraverseRelation[] { new TraverseRelation(\r
 348 //                        ThreeDimensionalModelingOntologyMapping.HAS_SUBNODES,\r
 349 //                        TraverseDirection.OUTBOUND)};\r
 350 //            }\r
 351 //            \r
 352 //            \r
 353 //        };\r
 354         \r
 355         IEntity IEntity = EntityFactory.create(graph, root);\r
 356         State s = new State() {};\r
 357         TraversalResult res = TraversalUtils.traverse(new TraversalRule (){\r
 358                 \r
 359                 \r
 360                 @Override\r
 361                 public boolean areAllStatesRelevant() {\r
 362                         return true;\r
 363                 }\r
 364                 \r
 365                 @Override\r
 366                 public TraversalDecision makeTraversalDecision(State state,\r
 367                                 Statement statement) {\r
 368                         if (statement.getPredicate().isInstanceOf(Resources.g3dResource.HasChild))\r
 369                                 return TraversalDecision.continueTraversal(state);\r
 370                         else\r
 371                                 return TraversalDecision.stopTraversal;\r
 372                 }\r
 373                 \r
 374                 @Override\r
 375                 public Collection<State> relevantStates() {\r
 376                         return null;\r
 377                 }\r
 378                 }, IEntity,s\r
 379                 );\r
 380         \r
 381     \r
 382         Set<Resource> cps = res.get(s);\r
 383         \r
 384         //Collection<Resource> cps = TraverseUtils.traverseGraph(root, handler);\r
 385         for (Resource r : cps) {\r
 386             G3DNode cp = new G3DNode(graph,r);\r
 387             if (cp.getLocalPosition() != null)\r
 388                 tt.storeProperty(cp.getLocalPosition().getResource(),G3DTools.getPoint(cp.getLocalPosition()));\r
 389             if (cp.getWorldPosition() != null)\r
 390                 tt.storeProperty(cp.getWorldPosition().getResource(),G3DTools.getPoint(cp.getWorldPosition()));\r
 391             if (cp.getLocalOrientation() != null)\r
 392                 tt.storeProperty(cp.getLocalOrientation().getResource(),G3DTools.getOrientation(cp.getLocalOrientation()));\r
 393             if (cp.getWorldOrientation() != null)\r
 394                 tt.storeProperty(cp.getWorldOrientation().getResource(),G3DTools.getOrientation(cp.getWorldOrientation()));\r
 395             \r
 396         }\r
 397     }\r
 398 \r
 399 }\r