IMP: unknown

Author: mboscolo

.gitignore

@@ -5,6 +5,7 @@
 
 class Main(http.Controller):
 
+    #localhost:8069/3dCad/render/1
     @http.route('/3dCad/render/<product_id>', methods=['GET'], auth='user', website=True)
     def render(self, product_id, **kwargs):
         return request.render("3dCad.threejs_main_view", {'main_product_product_id': product_id})

.settings/org.eclipse.core.resources.prefs

@@ -40,18 +40,18 @@ THREE.STLLoader.prototype = {
 
 	constructor: THREE.STLLoader,
 
-	load: function ( url, onLoad, onProgress, onError ) {
+	load: function ( url, data, onLoad, onProgress, onError ) {
 
-		var scope = this;
+        var scope = this;
+        scope.url = url;
+        scope.data = data;
 
 		var loader = new THREE.FileLoader( scope.manager );
 		loader.setPath( scope.path );
 		loader.setResponseType( 'arraybuffer' );
 		loader.load( url, function ( text ) {
-
 			try {
-
-				onLoad( scope.parse( text ) );
+				onLoad( scope.parse( text, scope.data) );
 
 			} catch ( exception ) {
 
@@ -74,7 +74,7 @@ THREE.STLLoader.prototype = {
 
 	},
 
-	parse: function ( data ) {
+	parse: function ( data, creationData ) {
 
 		function isBinary( data ) {
 
@@ -217,7 +217,8 @@ THREE.STLLoader.prototype = {
 			}
 
 			geometry.addAttribute( 'position', new THREE.BufferAttribute( new Float32Array( vertices ), 3 ) );
-			geometry.addAttribute( 'normal', new THREE.BufferAttribute( new Float32Array( normals ), 3 ) );
+            geometry.addAttribute( 'normal', new THREE.BufferAttribute( new Float32Array( normals ), 3 ) );
+            
 
 			if ( hasColors ) {
 
@@ -226,7 +227,6 @@ THREE.STLLoader.prototype = {
 				geometry.alpha = alpha;
 
 			}
-
 			return geometry;
 
 		}
@@ -294,7 +294,6 @@ THREE.STLLoader.prototype = {
 
 			geometry.addAttribute( 'position', new THREE.Float32BufferAttribute( vertices, 3 ) );
 			geometry.addAttribute( 'normal', new THREE.Float32BufferAttribute( normals, 3 ) );
-
 			return geometry;
 
 		}
@@ -334,8 +333,9 @@ THREE.STLLoader.prototype = {
 		// start
 
 		var binData = ensureBinary( data );
-
-		return isBinary( binData ) ? parseBinary( binData ) : parseASCII( ensureString( data ) );
+        var geometry = isBinary( binData ) ? parseBinary( binData ) : parseASCII( ensureString( data ) );
+        geometry.creationData = creationData;
+        return geometry;
 
 	}
 

odoo/addons/3dCad/__init__.py

@@ -18,6 +18,102 @@ var createDiv = function(parent, id){
     return out
 }
 
+var prepareStructure = function(data, parent){
+        let fOut = [];
+        for (var data_ix in data){
+            var group = data[data_ix];
+            if (parent){
+                group.location[0] += parent.location[0];
+                group.location[1] += parent.location[1];
+                group.location[2] += parent.location[2];
+                group.rotation[0] += parent.rotation[0];
+                group.rotation[1] += parent.rotation[1];
+                group.rotation[2] += parent.rotation[2];
+            }
+
+
+            for (var object_ix in group.objects){
+                var object = group.objects[object_ix];
+                //console.log(object.file + ' ' + parseInt(object.location[0],10) + ' ' + parseInt(object.location[1], 10) + ' ' + parseInt(object.location[2],10))
+                if (parent){
+                    object.location[0] += group.location[0];
+                    object.location[1] += group.location[1];
+                    object.location[2] += group.location[2];
+                    object.rotation[0] += group.rotation[0];
+                    object.rotation[1] += group.rotation[1];
+                    object.rotation[2] += group.rotation[2];
+                }
+                let r = Math.random().toString(36).substring(10);
+                fOut.push({
+                    unique_name: r,
+                    file: '/3dCad/static/data/' + object.file,
+                    p_x: parseInt(object.location[0] ,10),
+                    p_y: parseInt(object.location[1], 10),
+                    p_z: parseInt(object.location[2], 10),
+                    r_x: parseInt(object.rotation[0], 10),
+                    r_y: parseInt(object.rotation[1], 10),
+                    r_z: parseInt(object.rotation[2], 10),                   
+                });
+            }
+            let tempOut=prepareStructure(group.groups, group);
+            if (tempOut.length>0){
+                Array.prototype.push.apply(fOut, tempOut);
+            }
+        }
+        return fOut;
+}
+
+var load_stl = function (data, loader, scene){
+        let bbox = new THREE.Box3();
+        dataList.forEach(function(dataObject) {
+            loader.load(dataObject.file , dataObject, function ( geometry ) {
+                var innerGeometry = geometry;
+                dataList.forEach(function(dataObjectInner) {
+                    if (innerGeometry.creationData.unique_name===dataObjectInner.unique_name){
+                        var p_x = dataObjectInner.p_x;
+                        var p_y = dataObjectInner.p_y;
+                        var p_z = dataObjectInner.p_z;
+                        var r_x = dataObjectInner.r_x;
+                        var r_y = dataObjectInner.r_y;
+                        var r_z = dataObjectInner.r_z;
+                        console.log(dataObjectInner.file + ' ' + parseInt(r_x,10) + ' ' + parseInt(r_y, 10) + ' ' + parseInt(r_z,10));
+                        var material = new THREE.MeshPhongMaterial( { color: 0xff5533, specular: 0x111111, shininess: 200 } );
+                        var mesh = new THREE.Mesh( innerGeometry, material );
+                        mesh.position.set( p_x, p_y, p_z);
+                        mesh.rotation.set( r_x * 3.14 /180, r_y * 3.14 /180, r_z* 3.14 /180 );
+                        mesh.scale.set(1, 1, 1);
+                        mesh.castShadow = true;
+                        mesh.receiveShadow = true;
+                        mesh.geometry.computeBoundingBox();
+                        bbox.union(mesh.geometry.boundingBox);
+                        scene.add(mesh)
+                        var bBox_new = new FOUR.BoundingBox("Main Mesh", );
+                        bBox_new.update(bbox);
+                        camera.zoomToFit(bBox_new, true);
+                    }
+                });
+            })
+        });
+        return bbox;
+    }
+
+var load_table = function(scene, camera){
+    // load data structure
+        $.ajax({
+          type: "GET",
+          url: '/3dCad/static/data/json/freecad.json',
+          data: {},
+          dataType: 'json',
+          success: function(response){
+            let data = response;
+            var loader = new THREE.STLLoader();
+            load_stl(data['groups'], loader, scene, camera);
+          },
+          error: function(){
+            console.log('errore')
+          }
+        });
+}
 var createTestFour = function(divElement){
 
         var domElement = createDiv(divElement, 'viewport');
@@ -26,7 +122,7 @@ var createTestFour = function(divElement){
         var scene = new THREE.Scene();
 
         // camera
-        var camera = new FOUR.TargetCamera(50, domElement.width / domElement.height, 0.1, 1000);
+        var camera = new FOUR.TargetCamera(50, domElement.width / domElement.height, 0.1, 100);
         camera.position.set(0, -50, 0);
         camera.up = new THREE.Vector3(0, 0, 1);
         scene.add(camera);
@@ -40,9 +136,9 @@ var createTestFour = function(divElement){
         lights[1] = new THREE.PointLight(0xffffff, 1, 0);
         lights[2] = new THREE.PointLight(0xffffff, 1, 0);
 
-        lights[0].position.set(0, 180, 0);
-        lights[1].position.set(100, 180, 100);
-        lights[2].position.set(-100, -180, -100);
+        lights[0].position.set(0, 1800, 0);
+        lights[1].position.set(1000, 1800, 1000);
+        lights[2].position.set(-1000, -1800, -1000);
 
         scene.add(lights[0]);
         scene.add(lights[1]);
@@ -88,8 +184,10 @@ var createTestFour = function(divElement){
         mesh.position.y = Math.floor(0);
         mesh.position.z = Math.floor(0);
         cloud.add(mesh);        
+        
+        // custom load geometry
+        load_table(cloud, camera);
         scene.add(cloud);
-
         var axisHelper = new THREE.AxesHelper(20);
         scene.add(axisHelper);