;
//<script>
if( typeof(startupScripts) == 'undefined'){
var startupScripts = [
function(){},
function(){},
function(){},
function(){},
function(){},
function(){},
function(){},
function(){}
];
}
// Put recieved data about assembly into here. The code handles the rest.
// theXMLFile should be a string, and theSTLFiles as a binary ArrayBuffer
// Any text-based STL files should be in an 8-bit encoding
/**
*
* The function which handles the actual dir_rendering of the solution file animation
* and loading in the models
*
* @method dir_recieveData
* @for directionConfirmGlobal
* @param {String} theXMLFile
* @param {Object} theSTLFiles
* @return {Void}
*
*/
function dir_receiveData(theXMLFile, theSTLFiles){
theXML=theXMLFile;
parts.length=0;
var pos=0;
var lim=theSTLFiles.length;
var partGeom;
var partMesh;
while(pos<lim){
partGeom=null;
partGeom=theSTLFiles[pos];
if(partGeom===null){
partGeom=parseStlBinary(fileReaders[pos].Reader.result);
}
partMesh=new THREE.Mesh(
partGeom,
new THREE.MeshNormalMaterial()
);
parts.push({
Mesh: partMesh,
Name: fileReaders[pos].Name
})
scene.add(partMesh);
pos++;
}
dir_renderParts();
}
// Gets called when the user submits the table and everything is properly filled out
/**
*
* Is called whenever the user submits the part table and every entry has been
* properly filled out.
*
* @method dir_sendData
* @for directionConfirmGlobal
* @param {String} theXMLText The contents of the disassembly directions in the webpage, as a string
* in XML formatting
* @return {Void}
*
*/
function dir_sendData(theXMLText){
// Do whatever you want with the resulting data to send it off, if you want
}
/**
*
* Given an HTML element corresponding to a "confirm" button, moves the parent element
* to the confirmed section of the webpage
*
* @method dir_confirmPair
* @for directionConfirmGlobal
* @param {HTML Element} theButton The confirm button of the element to be moved
* @return {Void}
*
*/
function dir_confirmPair(theButton){
document.getElementById("confirmed").appendChild(theButton.parentElement);
theButton.innerHTML="unconfirm";
theButton.onclick=function(){
dir_deconfirmPair(theButton);
};
}
/**
*
* Given an HTML element corresponding to a "unconfirm" button, moves the parent element
* to the unconfirmed section of the webpage
*
* @method dir_deconfirmPair
* @for directionConfirmGlobal
* @param {HTML Element} theButton The unconfirm button of the element to be moved
* @return {Void}
*
*/
function dir_deconfirmPair(theButton){
document.getElementById("unconfirmed").appendChild(theButton.parentElement);
theButton.innerHTML="confirm";
theButton.onclick=function(){
dir_confirmPair(theButton);
};
}
/**
*
* Given an HTML element corresponding to a "focus" button, makes the corresponding pair
* of parts to be displayed
*
* @method dir_changeCurrentPair
* @for directionConfirmGlobal
* @param {HTML Element} theButton The confirm button of the element to be moved
* @return {Void}
*
*/
function dir_changeCurrentPair(theButton){
if(lastPair!==null){
return;
}
lastPair=currentPair;
var theRef=theButton.parentElement.Ref;
var theMov=theButton.parentElement.Mov;
var pos=0;
var lim=assemblyPairs.length;
while(pos<lim){
if(assemblyPairs[pos].Ref.Name===theRef & assemblyPairs[pos].Mov.Name===theMov){
currentPair=assemblyPairs[pos];
return;
}
pos++;
}
}
/**
*
* Given a jQuery object and a string, returns the first child of the given element with
* a tag equivalent to the given string.
*
* @method dir_grab
* @for directionConfirmGlobal
* @param {jQuery Object} theTree The jQuery object whose child is to be returned
* @param {String} theMember The name of the tag being searched
* @return {jQuery Object} The first child with the given tag. If such a child does not
* exist, null is returned.
*
*/
function dir_grab(theTree,theMember){
if($(theTree).children(theMember).length!=0){
return $(theTree).children(theMember)[0];
}
else{
return null;
}
}
var time=0;
var focusBox;
var focusPoint;
/**
*
* The dir_rendering function for the webpage
*
* @for directionConfirmGlobal
* @return {Void}
*
*/
var dir_render = function () {
// The function that will manage frame requests
requestAnimationFrame( dir_render );
if(lastPair!==null){
var holder=currentPair;
currentPair=lastPair;
dir_dehighlight(currentPair);
currentPair=holder;
dir_highlight(currentPair);
lastPair=null;
}
currentPair.Ref.Mesh.geometry.computeBoundingBox();
currentPair.Mov.Mesh.geometry.computeBoundingBox();
focusBox=currentPair.Ref.Mesh.geometry.boundingBox.clone();
focusBox.union(currentPair.Mov.Mesh.geometry.boundingBox);
focusPoint= new THREE.Vector3(
(focusBox.min.x+focusBox.max.x)/2,
(focusBox.min.y+focusBox.max.y)/2,
(focusBox.min.z+focusBox.max.z)/2
);
thePos.normalize();
thePos.applyEuler(theEul);
theEul.set(0,0,0,'XYZ');
thePos.multiplyScalar(theDistance);
camera.position.copy(thePos);
camera.position.add(focusPoint);
camera.lookAt(focusPoint);
camera.updateMatrix();
sunLight.position.set( (camera.position.x-focusPoint.x)*2+focusPoint.x,
(camera.position.y-focusPoint.y)*2+focusPoint.y,
(camera.position.z-focusPoint.z)*2+focusPoint.z );
sunLight.target.position=focusPoint;
time+=0.01;
dir_updateAxisLines();
// Call for the render
renderer.render(scene, camera);
};
/**
*
* Accepts a string and outputs the string of all characters following the final '.' symbol
* in the string. This is used internally to extract file extensions from file names.
*
* @method dir_grabExtension
* @for directionConfirmGlobal
* @param {String} theName The file name to be processed
* @return {String} the extension in the given file name. If no extension is found, the
* 'undefined' value is returned.
*
*/
function dir_grabExtension(theName){
return (/[.]/.exec(theName)) ? /[^.]+$/.exec(theName) : undefined;
}
// Returns from the given list of file readers those that have not completed loading
/**
*
* Outputs through the console the list of FileReaders in theReaders which have
* not yet completed their loading
*
* @method dir_whoIsLeft
* @for directionConfirmGlobal
* @param {FileReader Object List} theReaders The list of FileReaders to be checked
* @return {Void}
*
*/
function dir_whoIsLeft(theReaders){
var pos=0;
var lim=fileReaders.length;
var theList=[];
while(pos<lim){
if(theReaders[pos].Reader.readyState!=2){
theList.push(theReaders[pos].Name);
}
pos++;
}
console.log(theList);
}
/**
*
* Accepts a fileinput event, presumably from a file upload event listener, and assigns
* functions to each file reader listed in the event to be called upon the full loading
* of that given reader's files
*
* @method dir_readMultipleFiles
* @for directionConfirmGlobal
* @param {Event} evt A fileinput event, to be given by a fileinput event listener
* @return {Void}
*
*/
function dir_readMultipleFiles(evt) {
//Retrieve all the files from the FileList object
var files = evt.target.files;
if (files) {
for (var i=0, f; f=files[i]; i++) {
var r = new FileReader();
var extension=dir_grabExtension(f.name)[0];
//console.log(f.name);
if(extension===undefined){
continue;
}
if(extension.toLowerCase()==="stl"){
r.onload = (function(f) {
return function(e) {
//console.log(f.name);
var contents = e.target.result;
if(r.result!=null){
STLs.push(r.result);
}
dir_loadParts();
};
})(f);
r.readAsArrayBuffer(f);
fileReaders.push({Reader: r, Name: f.name});
}
else if(extension.toLowerCase()==="xml"){
console.log(f.name);
if(!(theXML===null)){
console.log("Warning: More than one XML file provided");
}
r.onload = (function(f) {
return function(e) {
//console.log(f.name);
var contents = e.target.result;
theXML=e.target.result;
dir_loadParts();
};
})(f);
r.readAsText(f,"US-ASCII");
fileReaders.push({Reader: r, Name: f.name});
}
}
console.log(fileReaders);
}
else {
alert("Failed to load files");
}
}
/**
*
* Called internally upon every recieved fileload event. Checks if every file reader in the
* array "fileReaders" has fully read each of their files. If so, then the function converts
* all recieved stl files into threeJS models and executes "dir_renderParts".
*
* @method dir_loadParts
* @for directionConfirmGlobal
* @return {Void}
*
*/
function dir_loadParts (){
// Looks for unloaded files
var pos=0;
var lim=fileReaders.length;
while(pos<lim){
if(!(fileReaders[pos].Reader.readyState===2)){
//console.log(pos);
//console.log(fileReaders[pos].Name);
break;
}
pos++;
}
// Executes if all files are loaded
if(pos===lim){
//console.log("ALL DONE");
parts.length=0;
pos=0;
var partGeom=null;
var partMesh;
var theCenter;
var ext;
while(pos<lim){
ext=dir_grabExtension(fileReaders[pos].Name)[0];
if(ext.toLowerCase()==="stl"){
partGeom=parseStl(fileReaders[pos].Reader.result);
if(partGeom===null){
partGeom=parseStlBinary(fileReaders[pos].Reader.result);
}
//console.log(partGeom);
partMesh=new THREE.Mesh(
partGeom,
new THREE.MeshLambertMaterial(wireSettings)
);
parts.push({
Mesh: partMesh,
Name: fileReaders[pos].Name
})
scene.add(partMesh);
}
pos++;
}
dir_renderParts();
}
}
function dir_renderParts(){
dir_parseData();
dir_linkParts();
console.log(assemblyPairs);
dir_highlight(assemblyPairs[0]);
lastPair=assemblyPairs[0];
currentPair=assemblyPairs[0];
dir_insertAssemblyPairs();
dir_initAxisLines();
dir_render();
}
/**
*
* Accepts two strings, a and b, and a vector, vec, and outputs a
* constructed part pair object if the two strings correspond to two
* extant parts
*
* @method dir_linkPair
* @for directionConfirmGlobal
* @param {String} a The first part name
* @param {String} b The second part name
* @param {Vector3} vec The vector to be added to the pair
* @return {Object} The resulting pair object
*
*/
function dir_linkPair(a,b,vec){
var thePair={Ref: null,
Mov: null,
Vec: null,
Directed: null,
DoublyDirected: null,
InfiniteDirections: null};
//console.log(parts);
var pos=0;
var lim=parts.length;
while(pos<lim){
if(parts[pos].Name===a+".STL" || parts[pos].Name===a){
thePair.Ref=parts[pos];
}
if(parts[pos].Name===b+".STL" || parts[pos].Name===b){
thePair.Mov=parts[pos];
}
if(thePair.Ref!==null && thePair.Mov!==null){
thePair.Vec=vec;
return thePair;
}
pos++;
}
//console.log(thePair);
return null;
}
/**
*
* Links together the pairs of parts corresponding to the strings present in
* the namePairs array.
*
* @method dir_linkParts
* @for directionConfirmGlobal
* @return {Void}
*
*/
function dir_linkParts(){
var pos=0;
var lim=namePairs.length;
var thePair=null;
while(pos<lim){
thePair=dir_linkPair(namePairs[pos].Ref,namePairs[pos].Mov,namePairs[pos].Vec);
if(thePair!=null){
thePair.InfiniteDirections = namePairs[pos].InfiniteDirections;
assemblyPairs.push(thePair);
}
pos++;
}
//console.log(assemblyPairs);
}
/**
*
* Populates the webpage with data stored int the global variable theSML
*
* @method dir_parseData
* @for directionConfirmGlobal
* @return {Void}
*
*/
function dir_parseData(){
//console.log(theXML);
var doc = $.parseXML(theXML);
//console.log(doc);
doc = dir_grab(doc,"DirectionSaveStructure");
var directions = dir_grab(doc,"Directions");
directions = $(directions).children("ArrayOfDouble");
var thePairs=dir_grab(doc,"arcs");
//console.log(thePairs);
thePairs=$(thePairs).children("arc");
//console.log(thePairs);
var pos=0;
var lim=thePairs.length;
var thePair;
var theMov;
var theRef;
var theVec;
var vecPos;
var vecLim;
var directed;
var docDirs;
var doublyDirected;
var docDubDirs;
var infiniteDirections;
var docInfDirs;
while(pos<lim){
theRef=dir_grab(thePairs[pos],"To");
theMov=dir_grab(thePairs[pos],"From");
docDirs=dir_grab(thePairs[pos],"directed");
directed=[];
docDubDirs=dir_grab(thePairs[pos],"doublyDirected");
doublyDirected=[];
docInfDirs=dir_grab(thePairs[pos],"InfiniteDirections");
infiniteDirections=[];
docFinDirs=dir_grab(thePairs[pos],"FiniteDirections");
finiteDirections=[];
if($(docDirs[vecPos]).innerHTML != "false"){
docDirs = $(docDirs).children("int");
vecPos=0;
vecLim=docDirs.length;
while(vecPos<vecLim){
theVec=parseInt(docDirs[vecPos].innerHTML);
directed.push(theVec);
vecPos++;
}
}
if($(docDubDirs[vecPos]).innerHTML != "false"){
docDubDirs = $(docDubDirs).children("int");
vecPos=0;
vecLim=docDubDirs.length;
while(vecPos<vecLim){
theVec=parseInt(docDubDirs[vecPos].innerHTML);
doublyDirected.push(theVec);
vecPos++;
}
}
if($(docInfDirs[vecPos]).innerHTML != "false"){
docInfDirs = $(docInfDirs).children("int");
vecPos=0;
vecLim=docInfDirs.length;
while(vecPos<vecLim){
theVec=parseInt(docInfDirs[vecPos].innerHTML);
infiniteDirections.push(theVec);
vecPos++;
}
}
theVec=dir_grab(thePairs[pos],"vector");
namePairs.push({
name: dir_grab(thePairs[pos],"name").innerHTML,
Ref: theRef.innerHTML,
Mov: theMov.innerHTML,
localLabels: dir_grab(thePairs[pos],"localLabels").innerHTML,
localVariables: dir_grab(thePairs[pos],"localVariables").innerHTML,
Directed: dir_grab(thePairs[pos],"Directed").innerHTML,
DoublyDirected: dir_grab(thePairs[pos],"DoublyDirected").innerHTML,
InfiniteDirections: infiniteDirections,
FiniteDirections: dir_grab(thePairs[pos],"FiniteDirections").innerHTML,
Fasteners: dir_grab(thePairs[pos],"Fasteners").innerHTML,
Certainty: dir_grab(thePairs[pos],"Certainty").innerHTML,
ConnectionType: dir_grab(thePairs[pos],"ConnectionType").innerHTML
});
pos++;
}
}
/**
*
* Populates the webpage with graphical representations of the assembly pairs
* stored in the global variable assemblyPairs
*
* @method dir_insertAssemblyPairs
* @for directionConfirmGlobal
* @return {Void}
*
*/
function dir_insertAssemblyPairs(){
var pos=0;
var lim=assemblyPairs.length;
while(pos<lim){
var theDiv = document.createElement("div");
var theText = document.createElement("text");
theText.innerHTML = assemblyPairs[pos].Ref.Name + " \n<---\n " + assemblyPairs[pos].Mov.Name;
var theConfBut = document.createElement("button");
theConfBut.innerHTML = "confirm";
theConfBut.onclick = function (){
dir_confirmPair(this);
}
var thedir_highlightBut = document.createElement("button");
thedir_highlightBut.innerHTML = "focus";
thedir_highlightBut.onclick = (function(position){
return function(){
lastPair=currentPair;
console.log("assigning currentPair");
console.log(position);
console.log(assemblyPairs[position]);
currentPair=assemblyPairs[position];
console.log ("Doing the focus thing");
}
})(pos);
theText.className="pairText";
theConfBut.className="dirButton";
thedir_highlightBut.className="dirButton";
theDiv.appendChild(theText);
theDiv.appendChild(document.createElement("br"));
theDiv.appendChild(thedir_highlightBut);
theDiv.appendChild(theConfBut);
theDiv.className="dirPair";
document.getElementById("unconfirmed").appendChild(theDiv);
pos++;
}
pos--;
}
/**
*
* dir_dehighlights the given pair of parts
*
* @method dir_dehighlight
* @for directionConfirmGlobal
* @param {Object} thePair The pair object to be dir_dehighlighted
* @return {Void}
*
*/
function dir_dehighlight(thePair){
console.log("The number of vectors is ",theVectors.length);
dir_removeVectorView(document.getElementById("expandButton"));
thePair.Ref.Mesh.material=new THREE.MeshLambertMaterial(wireSettings);
thePair.Mov.Mesh.material=new THREE.MeshLambertMaterial(wireSettings);
}
/**
*
* dir_highlights the given pair of parts
*
* @method dir_highlight
* @for directionConfirmGlobal
* @param {Object} thePair The pair object to be dir_highlighted
* @return {Void}
*
*/
function dir_highlight(thePair){
console.log(thePair);
thePair.Ref.Mesh.material=new THREE.MeshLambertMaterial({color: 0x4444FF /*, transparent: true, opacity: 0.6, depthTest: false */});
thePair.Mov.Mesh.material=new THREE.MeshLambertMaterial({color: 0xFF4444 /*, transparent: true, opacity: 0.6, depthTest: false */});
thePair.Ref.Mesh.geometry.computeBoundingBox();
thePair.Mov.Mesh.geometry.computeBoundingBox();
var theBox=thePair.Mov.Mesh.geometry.boundingBox.clone();
var distBox = thePair.Mov.Mesh.geometry.boundingBox.clone();
distBox.union(thePair.Ref.Mesh.geometry.boundingBox);
var pos=0;
var lim=theVectors.length;
while(pos<lim){
scene.remove( theVectors[pos] );
pos++;
}
theVectors.length=0;
console.log("Just set the Vectors to 0");
console.log("The pair is: ", thePair);
var theVec;
var theDist = Math.sqrt(Math.pow(distBox.max.x-distBox.min.x,2)+
Math.pow(distBox.max.y-distBox.min.y,2)+
Math.pow(distBox.max.y-distBox.min.y,2));
pos=0;
lim=thePair.InfiniteDirections.length;
while(pos<lim){
theVec = new THREE.Line( new THREE.Geometry(), new THREE.LineBasicMaterial({color: 0xff0000}));
theVec.geometry.vertices[0]=new THREE.Vector3(
(theBox.min.x+theBox.max.x)/2,
(theBox.min.y+theBox.max.y)/2,
(theBox.min.z+theBox.max.z)/2
);
theVec.geometry.vertices[1]=new THREE.Vector3(theDist*theDirections[thePair.InfiniteDirections[pos]].X,
theDist*theDirections[thePair.InfiniteDirections[pos]].Y,
theDist*theDirections[thePair.InfiniteDirections[pos]].Z);
theVec.geometry.vertices[1].add(theVec.geometry.vertices[0]);
theVec.geometry.verticesNeedUpdate=true;
scene.add(theVec);
theVectors.push(theVec);
console.log("Vector List Size is: ",theVectors.length);
pos++;
}
dir_insertVectorView(document.getElementById("expandButton"));
}
/**
*
* Sets the opacity of each (non-dir_highlighted) mesh object to the value of the
* slider element provided
*
* @method dir_fixOpacity
* @for directionConfirmGlobal
* @param {Object} theSlider The slider which is to be referenced when setting object opacity
* @return {Void}
*
*/
function dir_fixOpacity(theSlider){
console.log("Changing Opacity");
var val = theSlider.value;
wireSettings.opacity=val;
var pos=0;
var lim=parts.length;
while(pos<lim){
if(parts[pos].Mesh!=currentPair.Ref.Mesh && parts[pos].Mesh!=currentPair.Mov.Mesh){
parts[pos].Mesh.material=new THREE.MeshLambertMaterial(wireSettings);
}
pos++;
}
}
/**
*
* Given a mouseup event, sets corresponding internal button states for mouse-related controls
*
* @method dir_doMouseUp
* @for directionConfirmGlobal
* @param {mouseup event} theEvent
* @return {Void}
*
*/
function dir_doMouseUp(theEvent){
if(theEvent.button == 0){
leftDrag = false;
}
else if(theEvent.button == 2){
rightDrag = false;
}
}
/**
*
* Given a mousedown event, sets corresponding internal button states for mouse-related controls
*
* @method dir_doMouseDown
* @for directionConfirmGlobal
* @param {mousedown event} theEvent
* @return {Void}
*
*/
function dir_doMouseDown(theEvent){
if(theEvent.button == 0){
leftDrag = true;
}
else if(theEvent.button == 2){
rightDrag = true;
}
}
/**
*
* Given a mouseleave event, sets corresponding internal button states for mouse-related controls
*
* @method dir_doMouseLeave
* @for directionConfirmGlobal
* @param {mouseup event} theEvent
* @return {Void}
*
*/
function dir_doMouseLeave(theEvent){
leftDrag = false;
rightDrag = false;
lastMouse = null;
}
/**
*
* Prevents the default response of the given event (used to prevent dropdown menus when right
* clicking on the display).
*
* @method dir_justDont
* @for directionConfirmGlobal
* @param {Event Object} theEvent The event to suppress the default response of.
* @return {Void}
*
*/
function dir_justDont(theEvent){
theEvent.preventDefault();
}
/**
*
* Given a mousedrag event, rotates the camera or adds a vector to the currently displayed pair,
* depending upon whether or not the left or right mouse button is depressed
*
* @method dir_doDrag
* @for directionConfirmGlobal
* @param {mouseup event} theEvent
* @return {Void}
*
*/
function dir_doDrag(theEvent){
if(theAddAxis !== null){
var theBox=currentPair.Mov.Mesh.geometry.boundingBox.clone();
var theArea = document.getElementById("display");
var areaW = theArea.clientWidth;
var areaH = theArea.clientHeight;
var areaT = theArea.offsetTop;
var areaL = theArea.offsetLeft;
var mouseX = theEvent.clientX;
var mouseY = theEvent.clientY;
//console.log("aW: "+areaW+" aH: "+areaH+" aT: "+areaT+" aL: "+areaL);
//console.log("mX: "+(((mouseX-areaL)-areaW/2)/(areaW/2))+" mY: "+((areaH/2-(mouseY-areaT))/(areaH/2)));
var theDir = dir_getDirectionFromMouse( ((mouseX-areaL)-areaW/2)/(areaW/2), (areaH/2-(mouseY-areaT))/(areaH/2) );
theAddAxis.geometry.vertices[0].set((theBox.min.x+theBox.max.x)/2,(theBox.min.y+theBox.max.y)/2,(theBox.min.z+theBox.max.z)/2);
theAddAxis.geometry.vertices[1].set((theBox.min.x+theBox.max.x)/2+theDirections[theDir].X*theDistance*0.6,
(theBox.min.y+theBox.max.y)/2+theDirections[theDir].Y*theDistance*0.6,
(theBox.min.z+theBox.max.z)/2+theDirections[theDir].Z*theDistance*0.6 );
console.log( "X: "+(theBox.min.x+theBox.max.x)/2+
" Y: "+(theBox.min.y+theBox.max.y)/2+
" Z: "+(theBox.min.z+theBox.max.z)/2 );
console.log(" X: "+theDirections[theDir].X +
" Y: "+theDirections[theDir].Y +
" Z: "+theDirections[theDir].Z );
theAddAxis.geometry.verticesNeedUpdate=true;
}
if(leftDrag==true){
thePos.normalize();
theEul.set(theEvent.movementY*(-0.02)*Math.cos(Math.atan2(thePos.x,thePos.z)),
theEvent.movementX*(-0.02),
theEvent.movementY*(0.02)*Math.sin(Math.atan2(thePos.x,thePos.z)),
'ZYX');
}
if(rightDrag==true){
dir_addVectorFromMouse(theEvent.clientX, theEvent.clientY);
}
}
/**
*
* Given a mousewheel event, changes the distance of the camera from the center of the scene
*
* @method dir_doMouseUp
* @for directionConfirmGlobal
* @param {mouseup event} theEvent
* @return {Void}
*
*/
function dir_doZoom(theEvent){
var theDelta = theEvent.deltaY == 0 ? 0 : ( theEvent.deltaY > 0 ? 1 : -1 );
theDistance=theDistance*Math.pow(1.001,theDelta*(-40));
}
/**
*
* Inserts the vector view into the webpage
*
* @method dir_insertVectorView
* @for directionConfirmGlobal
* @param {HTML Element} theButton The vector viewing button
* @return {Void}
*
*/
function dir_insertVectorView(theButton){
console.log("doing dir_insertVectorView");
if(currentPair==null){
return;
}
currentPair.Ref.Mesh.geometry.computeBoundingBox();
currentPair.Mov.Mesh.geometry.computeBoundingBox();
var theBox=currentPair.Mov.Mesh.geometry.boundingBox.clone();
var distBox = currentPair.Mov.Mesh.geometry.boundingBox.clone()
distBox.union(currentPair.Ref.Mesh.geometry.boundingBox);
var theDist = Math.sqrt(Math.pow(distBox.max.x-distBox.min.x,2)+
Math.pow(distBox.max.y-distBox.min.y,2)+
Math.pow(distBox.max.y-distBox.min.y,2));
var theDiv=theButton.parentElement;
console.log(theDiv);
theButton.onclick=function () {dir_removeVectorView(this);};
var theVecList=document.createElement("div");
theVecList.id="vecList";
var addButton=document.createElement("button");
addButton.innerHTML="Add Vector";
addButton.id="addButton";
addButton.onclick=function () {dir_addVectorToPair(this);};
var pos=0;
var lim=theVectors.length;
var theEntry;
var remBut;
var xLab;
var xInp;
var yLab;
var yInp;
var zLabl;
var zInp;
while(pos<lim){
theEntry=document.createElement("div");
remBut=document.createElement("button");
remBut.innerHTML="Remove";
remBut.onclick=function () {dir_remVectorFromPair(this);};
xLab=document.createElement("text");
xLab.innerHTML="X";
xInp=document.createElement("input");
xInp.type="number";
xInp.step=0.01;
xInp.value=(theVectors[pos].geometry.vertices[1].x-theVectors[pos].geometry.vertices[0].x)/theDist;
xInp.onchange=function () {dir_vecEntryUpdate(this);};
yLab=document.createElement("text");
yLab.innerHTML="Y";
yInp=document.createElement("input");
yInp.type="number";
yInp.step=0.01;
yInp.value=(theVectors[pos].geometry.vertices[1].y-theVectors[pos].geometry.vertices[0].y)/theDist;
yInp.onchange=function () {dir_vecEntryUpdate(this);};
zLab=document.createElement("text");
zLab.innerHTML="Z";
zInp=document.createElement("input");
zInp.type="number";
zInp.step=0.01;
zInp.value=(theVectors[pos].geometry.vertices[1].z-theVectors[pos].geometry.vertices[0].z)/theDist;
zInp.onchange=function () {dir_vecEntryUpdate(this);};
theEntry.appendChild(xLab);
theEntry.appendChild(xInp);
theEntry.appendChild(document.createElement("br"));
theEntry.appendChild(yLab);
theEntry.appendChild(yInp);
theEntry.appendChild(document.createElement("br"));
theEntry.appendChild(zLab);
theEntry.appendChild(zInp);
theEntry.appendChild(document.createElement("br"));
theEntry.appendChild(remBut);
theEntry.counterPart=theVectors[pos];
theEntry.className="vecEntry";
theVecList.appendChild(theEntry);
pos++;
}
theDiv.appendChild(addButton);
theDiv.appendChild(theVecList);
}
/**
*
* Removes the vector view from the webpage
*
* @method dir_removeVectorView
* @for directionConfirmGlobal
* @param {HTML Element} theButton The vector viewing button
* @return {Void}
*
*/
function dir_removeVectorView(theButton){
console.log("doing dir_removeVectorView");
var theDiv=theButton.parentElement;
var vecListHolder=document.getElementById("vecList");
if(vecListHolder!=null){
var vecPos=0;
var vecLim=theVectors.length;
console.log(theVectors);
var best;
var ang;
var testVector;
currentPair.InfiniteDirections.length=0;
while(vecPos<vecLim){
testVector=new THREE.Vector3(1,1,1);
//
testVector.copy(theVectors[vecPos].geometry.vertices[1]);
testVector.sub(theVectors[vecPos].geometry.vertices[0]);
testVector.normalize();
//console.log(testVector);
pos=dir_getDir(testVector);
console.log(theVectors[vecPos]);
if(theVectors[vecPos].material.color.r===1){
currentPair.InfiniteDirections.push(pos);
console.log("<--->");
}
console.log("Vector List Size is: ",theVectors.length);
console.log("InfDir List Size is: ",currentPair.InfiniteDirections.length);
vecPos++;
}
theDiv.removeChild(vecListHolder);
theDiv.removeChild(document.getElementById("addButton"));
}
theButton.onclick=function () {dir_insertVectorView(this);};
}
/**
*
* Inserts a blank vector widget into the vector view element
*
* @method dir_addVectorToPair
* @for directionConfirmGlobal
* @param {HTML Element} theButton The "add vector" button
* @return {Void}
*
*/
function dir_addVectorToPair(theButton){
console.log("doing dir_addVectorToPair");
var theDiv=theButton.parentElement;
var theVecList=document.getElementById("vecList");
//console.log(theVecList);
var theEntry=document.createElement("div");
var remBut=document.createElement("button");
remBut.innerHTML="Remove";
remBut.onclick=function () {dir_remVectorFromPair(this);};
var xLab=document.createElement("text");
xLab.innerHTML="X";
var xInp=document.createElement("input");
xInp.type="number";
xInp.step=0.01;
xInp.onchange=function () {dir_vecEntryUpdate(this);};
var yLab=document.createElement("text");
yLab.innerHTML="Y";
var yInp=document.createElement("input");
yInp.type="number";
yInp.step=0.01;
yInp.onchange=function () {dir_vecEntryUpdate(this);};
var zLab=document.createElement("text");
zLab.innerHTML="Z";
var zInp=document.createElement("input");
zInp.type="number";
zInp.step=0.01;
zInp.onchange=function () {dir_vecEntryUpdate(this);};
theEntry.appendChild(xLab);
theEntry.appendChild(xInp);
theEntry.appendChild(document.createElement("br"));
theEntry.appendChild(yLab);
theEntry.appendChild(yInp);
theEntry.appendChild(document.createElement("br"));
theEntry.appendChild(zLab);
theEntry.appendChild(zInp);
theEntry.appendChild(document.createElement("br"));
theEntry.appendChild(remBut);
theEntry.counterPart=null;
theEntry.className="vecEntry";
theVecList.appendChild(theEntry);
return theEntry;
}
/**
*
* Removes a vector widget from the vector view element
*
* @method dir_remVectorFromPair
* @for directionConfirmGlobal
* @param {HTML Element} theButton The "remove" button of the widget to be removed
* @return {Void}
*
*/
function dir_remVectorFromPair(theButton){
console.log("doing dir_remVectorFromPair");
if(theButton.parentElement.counterPart!=null){
scene.remove(theButton.parentElement.counterPart);
}
console.log("The vector length before splice: ",theVectors.lenth);
theVectors.splice(theVectors.indexOf(theButton.parentElement.counterPart),1);
console.log("The vector length after splice: ",theVectors.lenth);
theButton.parentElement.parentElement.removeChild(theButton.parentElement);
}
/**
*
* Updates a vector to match the values in its corresponding widget
* @method dir_vecEntryUpdate
* @for directionConfirmGlobal
* @param {HTML Element} theInput An input element of the vector's widget
* @return {Void}
*
*/
function dir_vecEntryUpdate(theInput){
console.log("doing dir_vecEntryUpdate");
var theBox=currentPair.Mov.Mesh.geometry.boundingBox.clone();
currentPair.Ref.Mesh.geometry.computeBoundingBox();
currentPair.Mov.Mesh.geometry.computeBoundingBox();
var theBox=currentPair.Mov.Mesh.geometry.boundingBox.clone();
var distBox = currentPair.Mov.Mesh.geometry.boundingBox.clone();
distBox.union(currentPair.Ref.Mesh.geometry.boundingBox);
var theDist = Math.sqrt(Math.pow(distBox.max.x-distBox.min.x,2)+
Math.pow(distBox.max.y-distBox.min.y,2)+
Math.pow(distBox.max.y-distBox.min.y,2));
var theEntry=theInput.parentElement;
var theInputs=theEntry.getElementsByTagName("INPUT");
var pos=0;
var lim=theInputs.length;
var current;
while(pos<lim){
current=theInputs[pos];
if(theInputs[pos].value===""){
return;
}
pos++;
}
var theMag = Math.sqrt( Math.pow(parseFloat(theInputs[0].value),2)+
Math.pow(parseFloat(theInputs[1].value),2)+
Math.pow(parseFloat(theInputs[2].value),2));
theInputs[0].value = theInputs[0].value/theMag;
theInputs[1].value = theInputs[1].value/theMag;
theInputs[2].value = theInputs[2].value/theMag;
console.log(theInputs);
if(theEntry.counterPart===null){
var theVec = new THREE.Line( new THREE.Geometry(), new THREE.LineBasicMaterial({color: 0xff0000}));
theVec.geometry.vertices[0]=new THREE.Vector3(
(theBox.min.x+theBox.max.x)/2,
(theBox.min.y+theBox.max.y)/2,
(theBox.min.z+theBox.max.z)/2
);
theVec.geometry.vertices[1]=new THREE.Vector3(theVec.geometry.vertices[0].x+parseFloat(theInputs[0].value)*theDist,
theVec.geometry.vertices[0].y+parseFloat(theInputs[1].value)*theDist,
theVec.geometry.vertices[0].z+parseFloat(theInputs[2].value)*theDist);
scene.add(theVec);
theVectors.push(theVec);
console.log("theVectors Updated. New length is: ",theVectors.length);
theVec.geometry.verticesNeedUpdate=true;
theEntry.counterPart=theVec;
theEntry.counterPart.geometry.verticesNeedUpdate=true;
}
else{
var theVerts=theEntry.counterPart.geometry.vertices;
theVerts[1].x=theVerts[0].x+parseFloat(theInputs[0].value)*theDist;
theVerts[1].y=theVerts[0].y+parseFloat(theInputs[1].value)*theDist;
theVerts[1].z=theVerts[0].z+parseFloat(theInputs[2].value)*theDist;
theEntry.counterPart.geometry.verticesNeedUpdate=true;
}
console.log(theEntry.counterPart.geometry.vertices);
}
/**
*
* Finds and returns the index of the direction in the list of usable vector directions
* which best matches the given vector
*
* @method dir_getDir
* @for directionConfirmGlobal
* @param {Vector3} theVec The vector to be searched with
* @return {Int} The index of the best matching direction in the list of usable vector directions
*
*/
function dir_getDir(theVec){
var maxDot=-1;
var theDot;
var best=-1;
var pos=0;
var lim=theDirections.length;
while(pos<lim){
theDot=theDirections[pos].X*theVec.x+theDirections[pos].Y*theVec.y+theDirections[pos].Z*theVec.z;
if(theDot>maxDot){
maxDot=theDot;
best=pos;
}
pos++;
}
return best;
}
/**
*
* Processes the information in the webpage into an XML string and inserts a download link
* for the data into the top of the page
*
* @method dir_renderXML
* @for directionConfirmGlobal
* @return {Void}
*
*/
function dir_renderXML(){
var start= "<?xml version='1.0' encoding='utf-8'?>\n"+
"<DirectionSaveStructure xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>\n";
var end= "</DirectionSaveStructure>\n";
var arcContent = "<arcs>\n";
var idxPos;
var idxLim;
pos=0;
lim=namePairs.length;
while(pos<lim){
arcContent = arcContent+"<arc xsi:type='Connection'>\n";
arcContent = arcContent+"<name>"+namePairs[pos].name+"</name>\n";
arcContent = arcContent+"<localLabels>"+namePairs[pos].localLabels+"</localLabels>\n";
arcContent = arcContent+"<localVariables>"+namePairs[pos].localVariables+"</localVariables>\n";
arcContent = arcContent+"<From>"+namePairs[pos].Mov+"</From>\n";
arcContent = arcContent+"<To>"+namePairs[pos].Ref+"</To>\n";
arcContent = arcContent+"<directed>"+namePairs[pos].Directed+"</directed>\n";
arcContent = arcContent+"<doublyDirected>"+namePairs[pos].DoublyDirected+"</doublyDirected>\n";
arcContent = arcContent+"<InfiniteDirections> \n";
idxPos=0;
idxLim=namePairs[pos].InfiniteDirections.length;
while(idxPos<idxLim){
arcContent = arcContent+"<int>"+namePairs[pos].InfiniteDirections[idxPos].toString()+"</int>\n";
idxPos++;
}
arcContent = arcContent+"</InfiniteDirections>\n";
arcContent = arcContent+"<FiniteDirections>"+namePairs[pos].FiniteDirections+"</FiniteDirections>\n";
arcContent = arcContent+"<Fasteners>"+namePairs[pos].Fasteners+"</Fasteners>\n";
arcContent = arcContent+"<Certainty>"+namePairs[pos].Certainty+"</Certainty>\n";
arcContent = arcContent+"<ConnectionType>"+namePairs[pos].ConnectionType+"</ConnectionType>\n";
arcContent = arcContent+"</arc>\n";
pos++;
}
arcContent= arcContent + "</arcs>\n";
var result = start + arcContent + end;
outText = result;
requestAdvance(5);
}
/**
*
* Initializes the lines for the XYZ compass in the display
*
* @method dir_initAxisLines
* @for directionConfirmGlobal
* @return {Void}
*
*/
function dir_initAxisLines(){
theXAxis = new THREE.Line( new THREE.Geometry(), new THREE.LineBasicMaterial({color: 0xff0000, depthTest: false }));
theXAxis.geometry.vertices.push(new THREE.Vector3(0,0,0));
theXAxis.geometry.vertices.push(new THREE.Vector3(0,0,0));
theXAxis.frustumCulled = false;
theYAxis = new THREE.Line( new THREE.Geometry(), new THREE.LineBasicMaterial({color: 0x00ff00, depthTest: false }));
theYAxis.geometry.vertices.push(new THREE.Vector3(0,0,0));
theYAxis.geometry.vertices.push(new THREE.Vector3(0,0,0));
theYAxis.frustumCulled = false;
theZAxis = new THREE.Line( new THREE.Geometry(), new THREE.LineBasicMaterial({color: 0x0000ff, depthTest: false }));
theZAxis.geometry.vertices.push(new THREE.Vector3(0,0,0));
theZAxis.geometry.vertices.push(new THREE.Vector3(0,0,0));
theZAxis.frustumCulled = false;
theAddAxis = new THREE.Line( new THREE.Geometry(), new THREE.LineBasicMaterial({color: 0x00ff00, depthTest: true }));
theAddAxis.geometry.vertices.push(new THREE.Vector3(0,0,0));
theAddAxis.geometry.vertices.push(new THREE.Vector3(0,0,0));
theAddAxis.frustumCulled = false;
scene.add(theXAxis);
scene.add(theYAxis);
scene.add(theZAxis);
scene.add(theAddAxis);
}
/**
*
* Updates the lines for the XYZ compass in the display
*
* @method dir_updateAxisLines
* @for directionConfirmGlobal
* @return {Void}
*
*/
function dir_updateAxisLines(){
var theRot= new THREE.Quaternion(0,0,0,0);
theRot.setFromEuler(camera.rotation);
var theDir= new THREE.Vector3(-3,-3,-5);
theDir.applyQuaternion(theRot);
var thePosition = camera.position.clone();
thePosition.add(theDir);
theXAxis.geometry.vertices[0].copy(thePosition);
theXAxis.geometry.vertices[0].x-=0.5;
theXAxis.geometry.vertices[1].copy(thePosition);
theXAxis.geometry.vertices[1].x+=1;
theXAxis.geometry.verticesNeedUpdate=true;
theYAxis.geometry.vertices[0].copy(thePosition);
theYAxis.geometry.vertices[0].y-=0.5;
theYAxis.geometry.vertices[1].copy(thePosition);
theYAxis.geometry.vertices[1].y+=1;
theYAxis.geometry.verticesNeedUpdate=true;
theZAxis.geometry.vertices[0].copy(thePosition);
theZAxis.geometry.vertices[0].z-=0.5;
theZAxis.geometry.vertices[1].copy(thePosition);
theZAxis.geometry.vertices[1].z+=1;
theZAxis.geometry.verticesNeedUpdate=true;
}
/**
*
* Maps a given mouse X position and mouse Y position to a point on a unit hemisphere facing
* towards the user then returns the index of the closest valid direction
*
* @method dir_getDirectionFromMouse
* @for directionConfirmGlobal
* @param {Float} mouseX
* @param {Float} mouseY
* @return {Int}
*
*/
function dir_getDirectionFromMouse( mouseX, mouseY ){
var mouseZ;
mouseZ = Math.pow(1-((mouseX*mouseX)+(mouseY*mouseY)),0.5);
var theVec = new THREE.Vector3(mouseX,mouseY,mouseZ);
var theRot = new THREE.Euler( 0-Math.atan2(thePos.y,Math.sqrt(Math.pow(thePos.z,2)+Math.pow(thePos.x,2))),
Math.atan2(thePos.x,thePos.z),
0,
'ZYX' );
theVec.applyEuler(theRot);
var theDir = dir_getDir(theVec);
return theDir;
}
/**
*
* Adds a vector to the currently displayed pair based off of camera position, mouse X and mouse Y
*
* @method dir_addVectorFromMouse
* @for directionConfirmGlobal
* @param {Float} mouseX The X position of the mouse
* @param {Float} mouseY The Y position of the mouse
* @return {Void}
*
*/
function dir_addVectorFromMouse ( mouseX, mouseY ){
var theButton = document.getElementById("addButton");
var theArea = document.getElementById("display");
var areaW = theArea.clientWidth;
var areaH = theArea.clientHeight;
var areaT = theArea.offsetTop;
var areaL = theArea.offsetLeft;
console.log("aW: "+areaW+" aH: "+areaH+" aT: "+areaT+" aL: "+areaL);
console.log("mX: "+(((mouseX-areaL)-areaW/2)/(areaW/2))+" mY: "+((areaH/2-(mouseY-areaT))/(areaH/2)));
var theDir = dir_getDirectionFromMouse( ((mouseX-areaL)-areaW/2)/(areaW/2), (areaH/2-(mouseY-areaT))/(areaH/2) );
var theVecList=document.getElementById("vecList");
var theVecs = theVecList.childNodes;
var pos = 0;
var lim = theVecs.length;
var testVec = new THREE.Vector3(theDirections[theDir].X,theDirections[theDir].Y,theDirections[theDir].Z);
var otherVec = new THREE.Vector3(0,0,0);
while(pos<lim){
if(theVecs[pos]!==null){
otherVec.copy(theVecs[pos].counterPart.geometry.vertices[1]);
otherVec.sub(theVecs[pos].counterPart.geometry.vertices[0]);
if(testVec.angleTo(otherVec) < 0.15){
return;
}
}
pos++;
}
delete testVec;
delete otherVec;
var theElem = dir_addVectorToPair(theButton);
var theInputs = theElem.getElementsByTagName("input");
theInputs[0].value = theDirections[theDir].X;
theInputs[1].value = theDirections[theDir].Y;
theInputs[2].value = theDirections[theDir].Z;
theInputs[0].onchange();
}
startupScripts["4"] = function() {
lastPair=null;
currentPair=null;
theWidth=document.getElementById("display").clientWidth;
theHeight= document.getElementById("display").clientHeight;
// The scene of the assembly animation
//scene = new THREE.Scene();
// The camera
//camera = new THREE.PerspectiveCamera( 75, theWidth/theHeight, 1, 16000 );
document.getElementById("display").appendChild( renderer.domElement );
// Inserts the file loading manager into the document
//document.getElementById('fileinput').addEventListener('change', dir_readMultipleFiles, false);
document.getElementById("display").addEventListener("mousemove", dir_doDrag);
document.getElementById("display").addEventListener("wheel", dir_doZoom);
theXML = inText;
var i = 0;
var lim = directionList.length;
theDirections = [];
while( i < lim ){
theDirections.push({
X: directionList[i][0],
Y: directionList[i][1],
Z: directionList[i][2]
});
i++;
}
dir_renderParts();
}
//</script>
