1 /*******************************************************************************
\r
2 * Copyright (c) 2007 VTT Technical Research Centre of Finland and others.
\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
9 * VTT Technical Research Centre of Finland - initial API and implementation
\r
10 *******************************************************************************/
\r
11 package org.simantics.proconf.g3d.base;
\r
13 import java.util.Collection;
\r
14 import java.util.Set;
\r
15 import java.util.Stack;
\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
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
44 * Basic ThreeDimensionalModelingOntology tools
\r
46 * @author Marko Luukkainen
\r
49 public class G3DTools {
\r
51 private static boolean DEBUG = false;
\r
53 private static TransformationTools tt;
\r
55 public static void initialize() {
\r
56 tt = new TransformationTools(Resources.g3dResource.HasChild, Resources.g3dResource.HasParent);
\r
59 public static void deinitialize() {
\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
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
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
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
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
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
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
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
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
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
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
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
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
147 public static void multiplyOrientation(IEntity r, AxisAngle4d rot) {
\r
148 AxisAngle4d current = getOrientation(r);
\r
149 Quat4d q1 = new Quat4d();
\r
151 Quat4d q2 = new Quat4d();
\r
156 setOrientation(r, rot);
\r
160 public static AxisAngle4d getWorldFromLocal(IEntity node, AxisAngle4d localRot) {
\r
161 return tt.getWorldFromLocal(node, localRot);
\r
164 public static Point3d getWorldFromLocal(IEntity node, Point3d localRot) {
\r
165 return tt.getWorldFromLocal(node, localRot);
\r
168 public static AxisAngle4d getLocalFromWorld(IEntity node, AxisAngle4d localRot) {
\r
169 return tt.getLocalFromWorld(node, localRot);
\r
172 public static Point3d getLocalFromWorld(IEntity node, Point3d localRot) {
\r
173 return tt.getLocalFromWorld(node, localRot);
\r
176 public static void propagateLocalTransformChange(IEntity node, IEntity child) {
\r
177 tt.propagateLocalTransformChange(node, child);
\r
180 public static void propagateWorldTransformChange(IEntity node, IEntity child) {
\r
181 tt.propagateWorldTransformChange(node, child);
\r
184 public static void transformationUpdate(Graph graph, Resource resource) {
\r
185 tt.transformationUpdate(graph, resource);
\r
188 public static void resetTransformation(IEntity shape) {
\r
189 Graph graph = shape.getGraph();
\r
190 if (shape.getAtMostOneRelatedObject(Resources.g3dResource.HasLocalPosition) == null) {
\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
202 p2.setX(new double[] { 0.0 });
\r
203 p2.setY(new double[] { 0.0 });
\r
204 p2.setZ(new double[] { 0.0 });
\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
210 if (shape.getAtMostOneRelatedObject(Resources.g3dResource.HasLocalOrientation) == null) {
\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
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
236 public static G3DNode getModelFromResource(Graph graph,Resource resource) {
\r
237 G3DNode node = new G3DNode(graph, resource);
\r
239 G3DNode parent = node.getParent();
\r
240 if (parent == null)
\r
248 * Checks if instance has a certain property instance
\r
250 * @param propertyInstance
\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
261 while (!props.isEmpty()) {
\r
262 IEntity property = props.pop();
\r
263 if (property.getResource().equals(propertyInstance)) {
\r
266 res = property.getRelatedObjects(builtins.HasProperty);
\r
267 for (IEntity r : res) {
\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
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
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
295 Collection<IEntity> sub = entity.getRelatedObjects(Resources.g3dResource.HasGeometryDefinition);
\r
296 if (sub.size() > 0)
\r
297 instances.addAll(sub);
\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
306 while (!props.isEmpty()) {
\r
307 IEntity property = props.pop();
\r
308 if (property.equals(propertyInstance)) {
\r
311 res = property.getRelatedObjects(builtins.HasProperty);
\r
312 for (IEntity r : res) {
\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
334 * Loads positions of control point to rule cache
\r
336 * @param root resource of the modeled plant
\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
346 // public TraverseRelation[] traverseFromResource(Resource resource) {
\r
347 // return new TraverseRelation[] { new TraverseRelation(
\r
348 // ThreeDimensionalModelingOntologyMapping.HAS_SUBNODES,
\r
349 // TraverseDirection.OUTBOUND)};
\r
355 IEntity IEntity = EntityFactory.create(graph, root);
\r
356 State s = new State() {};
\r
357 TraversalResult res = TraversalUtils.traverse(new TraversalRule (){
\r
361 public boolean areAllStatesRelevant() {
\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
371 return TraversalDecision.stopTraversal;
\r
375 public Collection<State> relevantStates() {
\r
382 Set<Resource> cps = res.get(s);
\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