bundles/addons/org.eclipse.apogy.addons/src-gen-custom/org/eclipse/apogy/addons/impl/AbstractTwoPoints3DToolCustomImpl.java

/*******************************************************************************
 * Copyright (c) 2018 Agence spatiale canadienne / Canadian Space Agency 
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Pierre Allard, 
 *     Regent L'Archeveque - initial API and implementation
 *
 * SPDX-License-Identifier: EPL-1.0
 *     
 *******************************************************************************/
package org.eclipse.apogy.addons.impl;

import javax.vecmath.Matrix4d;
import javax.vecmath.Point3d;

import org.eclipse.apogy.addons.ApogyAddonsPackage;
import org.eclipse.apogy.common.emf.transaction.ApogyCommonTransactionFacade;
import org.eclipse.apogy.common.math.ApogyCommonMathFacade;
import org.eclipse.apogy.common.math.Tuple3d;
import org.eclipse.apogy.common.topology.ApogyCommonTopologyFacade;
import org.eclipse.apogy.common.topology.Node;
import org.eclipse.apogy.common.topology.util.NodeRelativePoseListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public abstract class AbstractTwoPoints3DToolCustomImpl extends AbstractTwoPoints3DToolImpl {

	private static final Logger Logger = LoggerFactory.getLogger(AbstractTwoPoints3DToolImpl.class);

	private NodeRelativePoseListener nodeRelativePoseListener;

	@Override
	public void setFromRelativePosition(Tuple3d newFromRelativePosition) {
		super.setFromRelativePosition(newFromRelativePosition);
		updateFromAbsolutePosition();
		updateDistance();
	}

	@Override
	public void setFromNode(Node newFromNode) {
		super.setFromNode(newFromNode);
		updateFromAbsolutePosition();
		updateDistance();
		getNodeRelativePoseListener().setFromNode(newFromNode);
	}

	@Override
	public void setToRelativePosition(Tuple3d newToRelativePosition) {
		super.setToRelativePosition(newToRelativePosition);
		updateToAbsolutePosition();
		updateDistance();
	}

	@Override
	public void setToNode(Node newToNode) {
		super.setToNode(newToNode);
		updateToAbsolutePosition();
		updateDistance();
		getNodeRelativePoseListener().setToNode(newToNode);
	}

	@Override
	public abstract void pointsRelativePoseChanged(Matrix4d newPose);

	@Override
	public void dispose() {
		if (this.nodeRelativePoseListener != null) {
			this.nodeRelativePoseListener.dispose();
			this.nodeRelativePoseListener = null;
		}

		super.dispose();
	}

	@Override
	public void setRootNode(Node newRootNode) {
		super.setRootNode(newRootNode);

		if (getToNodeNodePath() != null) {
			if (!isToNodeLock()) {
				Node to = ApogyCommonTopologyFacade.INSTANCE.resolveNode(getRootNode(), getToNodeNodePath());
				ApogyCommonTransactionFacade.INSTANCE.basicSet(this,
						ApogyAddonsPackage.Literals.ABSTRACT_TWO_POINTS3_DTOOL__TO_NODE, to);
			}
		}

		if (getFromNodeNodePath() != null) {
			if (!isFromNodeLock()) {
				Node from = ApogyCommonTopologyFacade.INSTANCE.resolveNode(getRootNode(), getFromNodeNodePath());
				ApogyCommonTransactionFacade.INSTANCE.basicSet(this,
						ApogyAddonsPackage.Literals.ABSTRACT_TWO_POINTS3_DTOOL__FROM_NODE, from);
			}
		}
	}

	@Override
	public void variablesInstantiated() {
		if (getToNodeNodePath() != null) {
			if (!isToNodeLock()) {
				Node to = ApogyCommonTopologyFacade.INSTANCE.resolveNode(getRootNode(), getToNodeNodePath());
				ApogyCommonTransactionFacade.INSTANCE.basicSet(this,
						ApogyAddonsPackage.Literals.ABSTRACT_TWO_POINTS3_DTOOL__TO_NODE, to);
			}
		}

		if (getFromNodeNodePath() != null) {
			if (!isFromNodeLock()) {
				Node from = ApogyCommonTopologyFacade.INSTANCE.resolveNode(getRootNode(), getFromNodeNodePath());
				ApogyCommonTransactionFacade.INSTANCE.basicSet(this,
						ApogyAddonsPackage.Literals.ABSTRACT_TWO_POINTS3_DTOOL__FROM_NODE, from);
			}
		}
	}

	@Override
	public void variablesCleared() {
		// Nothing to do.
	}

	/*
	 * Updates the absolute position of the FROM node.
	 */
	protected void updateFromAbsolutePosition() {
		// Updates From Node Absolute Position.
		if (getFromNode() != null) {
			Matrix4d m = ApogyCommonTopologyFacade.INSTANCE.expressNodeInRootFrame(getFromNode());
			Point3d from = new Point3d();
			if (getFromRelativePosition() != null) {
				from = new Point3d(getFromRelativePosition().asTuple3d());
			}
			m.transform(from);

			// Updates the FromAbsolutePosition.
			ApogyCommonTransactionFacade.INSTANCE.basicSet(this,
					ApogyAddonsPackage.Literals.ABSTRACT_TWO_POINTS3_DTOOL__FROM_ABSOLUTE_POSITION,
					ApogyCommonMathFacade.INSTANCE.createTuple3d(from));
		}
	}

	/*
	 * Updates the absolute position of the TO node.
	 */
	protected void updateToAbsolutePosition() {
		// Updates To Node Absolute Position.
		if (getToNode() != null) {
			Matrix4d m = ApogyCommonTopologyFacade.INSTANCE.expressNodeInRootFrame(getToNode());
			Point3d to = new Point3d();
			if (getToRelativePosition() != null) {
				to = new Point3d(getToRelativePosition().asTuple3d());
			}
			m.transform(to);

			// Updates the ToAbsolutePosition.
			ApogyCommonTransactionFacade.INSTANCE.basicSet(this,
					ApogyAddonsPackage.Literals.ABSTRACT_TWO_POINTS3_DTOOL__TO_ABSOLUTE_POSITION,
					ApogyCommonMathFacade.INSTANCE.createTuple3d(to));
		}
	}

	/**
	 * Forces To and FROM node to be resolved.
	 */
	protected void forceToAndFromReload() {
		if (getRootNode() != null) {
			if (getFromNode() == null && getFromNodeNodePath() != null) {
				try {
					Node from = ApogyCommonTopologyFacade.INSTANCE.resolveNode(getRootNode(), getFromNodeNodePath());
					ApogyCommonTransactionFacade.INSTANCE.basicSet(this,
							ApogyAddonsPackage.Literals.ABSTRACT_TWO_POINTS3_DTOOL__FROM_NODE, from);
				} catch (Exception e) {
					Logger.error(e.getMessage(), e);
				}
			}

			if (getToNode() == null && getToNodeNodePath() != null) {
				try {
					Node to = ApogyCommonTopologyFacade.INSTANCE.resolveNode(getRootNode(), getToNodeNodePath());
					ApogyCommonTransactionFacade.INSTANCE.basicSet(this,
							ApogyAddonsPackage.Literals.ABSTRACT_TWO_POINTS3_DTOOL__TO_NODE, to);
				} catch (Exception e) {
					Logger.error(e.getMessage(), e);
				}
			}
		}
	}

	protected void updateDistance() {
		double distance = 0.0;
		if (getFromAbsolutePosition() != null && getToAbsolutePosition() != null) {
			Point3d from = new Point3d(getFromAbsolutePosition().asTuple3d());
			Point3d to = new Point3d(getToAbsolutePosition().asTuple3d());
			distance = to.distance(from);
		}

		// Updates the distance.
		ApogyCommonTransactionFacade.INSTANCE.basicSet(this,
				ApogyAddonsPackage.Literals.ABSTRACT_TWO_POINTS3_DTOOL__DISTANCE, distance);
	}

	protected NodeRelativePoseListener getNodeRelativePoseListener() {
		if (this.nodeRelativePoseListener == null) {
			this.nodeRelativePoseListener = new NodeRelativePoseListener() {
				@Override
				public void relativePoseChanged(Matrix4d newPose) {
					if (!isDisposed()) {
						// Updates both node absolute position.
						updateFromAbsolutePosition();
						updateToAbsolutePosition();

						// Updates distance
						updateDistance();

						pointsRelativePoseChanged(newPose);
					}
				}
			};
		}
		return this.nodeRelativePoseListener;
	}
} // AbstractTwoPoints3DToolImpl