geometry.js

const { isRegExp } = require("util");
// Amira Abdel-Rahman
// (c) Massachusetts Institute of Technology 2020

var solveFea;
var _rhino3dm = null;
var occupancy=[];
var gridSize=10;


// initialize 
function latticeSetup(setup,latticeSize,voxelSize,voxelBuilder,forces,material) {//later change type to dictiary
	
	// console.log(_rhino3dm);
    // var voxelSize=10.0;
	// var latticeSize=5;
	// const material={
	// 	area:1.0,
	// 	density:0.028,
	// 	stiffness:1000000
	// };

    createLattice(setup,voxelSize,latticeSize,latticeSize,latticeSize,voxelBuilder,material);

	
	//todo fix this
	if(setup.hierarchical){
		addForceAbove(setup,0.75*voxelSize*latticeSize,forces);
		restrainBelow(setup,voxelSize*0.75);
	}else{
		addForceAbove(setup,0.8*voxelSize*latticeSize,forces);
		restrainBelow(setup,-voxelSize/2);
	}
}

///
function lateralLoadSetup(setup,position,length,voxelSize,voxelBuilder,supports,loads,material) {

	createLattice(setup,voxelSize,1,1,length,voxelBuilder,material,position);
	
	//todo incorporate this into the drawing phase so you don't have to loop twice
	restrainFromBox(setup,supports);
	loadFromBox(setup,loads);
}

function lateralLoadSetup1(setup,position,length,voxelSize,voxelBuilder,supports,loads,material) {

	createLattice(setup,voxelSize,1,length,1,voxelBuilder,material,position);
	
	//todo incorporate this into the drawing phase so you don't have to loop twice
	restrainFromBox(setup,supports);
	loadFromBox(setup,loads);
}

////////////////////////////////////////////////////////////
function createLattice(setup,size,sizeX,sizeY,sizeZ,voxelBuilder,material,position=new THREE.Vector3(0,0,0)){

	for (var i=0;i<gridSize;++i){
        occupancy.push([]);
        for (var j=0;j<gridSize;++j){
            occupancy[i].push([]);
            for (var k=0;k<gridSize;++k){
                occupancy[i][j].push(-1);
            }
        }
	}
	
	var count=0;	

    for(var i=0;i<sizeX;i++){
        for(var j=0;j<sizeY;j++){
            for(var k=0;k<sizeZ;k++){
				// if(i>sizeX/3){
				// 	stiffness=100000;
				// }
				voxelBuilder(setup,size,new THREE.Vector3(i*size+position.x,j*size+position.y,k*size+position.z),material);
			}
        }
	}
}

function createLatticeFromFrep(setup,size,frep,voxelBuilder,material,position=new THREE.Vector3(0,0,0)){
	for (var i=0;i<gridSize;++i){
        occupancy.push([]);
        for (var j=0;j<gridSize;++j){
            occupancy[i].push([]);
            for (var k=0;k<gridSize;++k){
                occupancy[i][j].push(-1);
            }
        }
	}
	for(var i=0;i<gridSize;i++){
        for(var j=0;j<gridSize;j++){
            for(var k=0;k<gridSize;k++){
				if(frep(i,j,k)>0){
					voxelBuilder(setup,size,new THREE.Vector3(i*size+position.x,j*size+position.y,k*size+position.z),material);
				}
			}
        }
	}
}

function createGeometryFromRhino(setup,fileName,layerIndex,voxelSize,sizeX,sizeY,sizeZ,material){
	let rhinoFile= fs.readFileSync(fileName);
	let doc = _rhino3dm.File3dm.fromByteArray(rhinoFile);

	let objects = doc.objects();

	

	let counter=0;

	function useLayer(layer,layerIndex,useMaterialList){
		if(useMaterialList){
			
			if(layerIndex.some(elem => elem == layer)){

				const isLayer = (element) => element == layer;

				// console.log("materialIdex1 "+(parseInt(layerIndex.findIndex(isLayer))+2.0))
				// console.log((parseInt(layerIndex.findIndex(isLayer))+2.0))
				return (parseInt(layerIndex.findIndex(isLayer))+2.0);
			}else{
				return false;
			}
			
		}else{
			return layer==layerIndex;
		}
	}
	for (let ii = 0; ii < objects.count; ii++) {
		let object = objects.get(ii).geometry();
		let layer=objects.get(ii).attributes().layerIndex;

		let materialIndex=useLayer(layer,layerIndex,setup.useMaterialList); //0 if doesn't exists, 1 if exists but not material list, >1 if exists and use material list
		// console.log("materialIndex "+materialIndex)
		if((object instanceof _rhino3dm.LineCurve ||object instanceof _rhino3dm.NurbsCurve ||object instanceof _rhino3dm.PolylineCurve )&& materialIndex>0 ) { //only get lines no nurbs curves
			// console.log("yes!")
			for(var i=0;i<sizeX;i++){
				for(var j=0;j<sizeY;j++){
					for(var k=0;k<sizeZ;k++){
						var pos= new THREE.Vector3(i*voxelSize,j*voxelSize,k*voxelSize);
						var pos1=new THREE.Vector3(object.pointAtStart[0]+pos.x,object.pointAtStart[2]+pos.y,object.pointAtStart[1]+pos.z);
						var pos2=new THREE.Vector3(  object.pointAtEnd[0]+pos.x,  object.pointAtEnd[2]+pos.y,  object.pointAtEnd[1]+pos.z);

						var source = checkandAdd(setup,pos1,material);
						var target = checkandAdd(setup,pos2,material);

						if(materialIndex==1){
							addEdge(setup,source,target,material);
						}else{
							addEdge(setup,source,target,setup.materialList[materialIndex-2]);
						}
						
					}
				}
			}
		}else if(layer==layerIndex){
			console.log("Warning: unknown object imported from Rhino on layer:"+object)
		}
	}

	setup.materialList=[];//don't need it anymore

}

function createVoxel(setup,size,position,material){
    

    // var sphere = new _rhino3dm.Sphere([0,0,0], size/2);
	// var box = sphere.toBrep().getBoundingBox();
	var box=new _rhino3dm.BoundingBox([0,0,0], [size,size,size]);
    // console.log(box.min)
	box = box.toBrep();
	
	// position.x-=size/2;
	// position.y-=size/2;
	// position.z-=size/2;
    
    for(var i=0; i<6;i++){//for each face

        // var restrained=false;
        // var force=new THREE.Vector3(0,0,0);
        // if(i==0){
        //     restrained=true;
        // }
        // if(i==2){
        //     force=new THREE.Vector3(0,-200,0);
        //     // restrained=true;
        // }
        nodesIndices=[];
        var face=box.faces().get(i);
        
        
		nodesIndices.push(checkandAdd(setup,add(position,toPosition(face.pointAt(size  , size/2))),material) );
        nodesIndices.push(checkandAdd(setup,add(position,toPosition(face.pointAt(size/2, 0     ))),material) );
        nodesIndices.push(checkandAdd(setup,add(position,toPosition(face.pointAt(0     , size/2))),material) );
        nodesIndices.push(checkandAdd(setup,add(position,toPosition(face.pointAt(size/2, size  ))),material) );
        
        linkNodes(setup,nodesIndices,material);