Changeset 644 in main for branches


Ignore:
Timestamp:
01/17/12 08:43:52 (9 years ago)
Author:
agalech
Message:
 
Location:
branches/3D/openPLM/document3D
Files:
3 added
5 edited

Legend:

Unmodified
Added
Removed
  • branches/3D/openPLM/document3D/Mesh.py

    r614 r644  
    4141# for debugging and optimization 
    4242import time 
    43  
     43import os, os.path 
     44from openPLM.document3D.models import * 
     45import time 
     46 
     47 
     48 
     49def procesing_simples_shapes(my_shapes_simples,doc_file): 
     50 
     51 
     52    fileName, fileExtension = os.path.splitext(doc_file.filename) 
     53    init_time = time.time()     
     54    for i, shape in enumerate(my_shapes_simples): 
     55            new_stp_jss= stp_to_jss() 
     56            new_stp_jss.stp = doc_file 
     57            print "processing mesh " ,shape.nom ,   " " , i+1 , "/" ,len(my_shapes_simples) 
     58            my_mesh = mesh_shape(shape.shape) 
     59            name = new_stp_jss.js.storage.get_available_name(fileName+".js") 
     60            path = os.path.join(new_stp_jss.js.storage.location, name) 
     61            if(not mesh_to_3js(my_mesh,path.encode(),"_"+str(i))): 
     62                print "Error generating fichier .JS for shape : " ,shape.nom  
     63                return False     
     64            else: 
     65 
     66                new_stp_jss.js = name 
     67                new_stp_jss.index = i 
     68                new_stp_jss.save() 
     69                 
     70    print '\n\nFinisehd computation of all shapes in %fs'%(time.time()-init_time) 
     71 
     72def mesh_shape(shape): 
     73    """ Take a topods_shape instance, returns the tesselated object""" 
     74    ''' Connect a ode.Trimesh to this body. The mesh is generated from the MSH subpackage. vertices lits 
     75    and faces indices are passed to the trimesh. 
     76    The default mesh precision is divided by the quality factor: 
     77    - if quality_factor>1, the mesh will be more precise, i.e. more triangles (more precision, but also 
     78    more memory consumption and time for the mesher, 
     79    - if quality_factor<1, the mesh will be less precise. 
     80    By default, this argument is set to 1 : the default precision of the mesher is used. 
     81    ''' 
     82    quality_factor=1 
     83    a_mesh = QuickTriangleMesh(DISPLAY_LIST=True) 
     84    a_mesh.set_shape(shape) 
     85    a_mesh.set_precision(a_mesh.get_precision()/quality_factor) 
     86    a_mesh.compute() 
     87    return a_mesh        
     88 
     89 
     90 
     91def mesh_to_3js(mesh,filename,name): 
     92    """ Take a mesh, exports to a three.js javascript file""" 
     93 
     94 
     95     
     96    try: 
     97        directory = os.path.dirname(filename) 
     98         
     99        if not os.path.exists(directory): 
     100            os.makedirs(directory) 
     101 
     102        output = open(filename,"w") 
     103        output.write(""" 
     104    var %s = function () { 
     105 
     106    var scope = this; 
     107    THREE.Geometry.call( this ); 
     108        """%name) 
     109        # export vertices 
     110        for vertex in mesh.get_vertices(): 
     111 
     112           output.write('v(%.4f,%.4f,%.4f);\n'%(vertex[0],vertex[1],vertex[2])) 
     113        # export faces 
     114        index = 0 
     115        faces = mesh.get_faces() 
     116        normals = mesh.get_normals() 
     117        while index<len(faces)-2: 
     118            n1 = normals[index] 
     119            n2 = normals[index+1] 
     120            n3 = normals[index+2] 
     121            output.write('f3(%i,%i,%i,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f);\n'%(faces[index],faces[index+1],faces[index+2],n1[0],n1[1],n1[2],n2[0],n2[1],n2[2],n3[0],n3[1],n3[2])) 
     122             
     123            index += 3 
     124         
     125        #closing file 
     126        #this.sortFacesByMaterial(); 
     127        output.write(""" 
     128     
     129    function v( x, y, z ) { 
     130        scope.vertices.push( new THREE.Vertex( new THREE.Vector3( x, y, z )  ) ); 
     131        } 
     132    function f3( a, b, c, n1_x,n1_y,n1_z,n2_x,n2_y,n2_z,n3_x,n3_y,n3_z ) { 
     133        scope.faces.push( new THREE.Face3( a, b, c, [ new THREE.Vector3( n1_x, n1_y, n1_z ), new THREE.Vector3( n2_x, n2_y, n2_z ), new THREE.Vector3( n3_x, n3_y, n3_z ) ]  ) ); 
     134        } 
     135        } 
     136 
     137    %s.prototype = new THREE.Geometry(); 
     138    %s.prototype.constructor = %s; 
     139        """%(name,name,name)) 
     140        output.close() 
     141        return True 
     142    except IOError as (errno, strerror): 
     143        print "I/O error({0}): {1}".format(errno, strerror) 
     144        return False 
     145     
    44146 
    45147 
  • branches/3D/openPLM/document3D/STP_converter_WebGL.py

    r614 r644  
    2525from OCC import XCAFApp, TDocStd, XCAFDoc, gp 
    2626from OCC.Utils.Topology import Topo 
    27 from OCC.Quantity import Quantity_Color 
    28  
     27from OCC.Quantity import * 
     28 
     29 
     30#para el exporter 
     31from OCC.TCollection import * 
     32from OCC.TopoDS import * 
     33from OCC.XSControl import * 
     34from OCC.STEPControl import * 
    2935 
    3036 
     
    3238class NEW_STEP_Import(object): 
    3339 
     40 
     41    
     42     
    3443    def __init__(self, filename, layer_name='layer-00'): 
    3544        self.filename = filename 
    3645        self._shapes_simples = [] #an empty string 
    3746        self._shapes_arbre= [] 
     47        self._shape_tool =0 
     48        self._color_tool =0 
    3849 
    3950    def get_color_tool(self): 
     
    4354    def get_shapes_arbre(self): 
    4455        return self._shapes_arbre 
     56    def get_shapes_tool(self): 
     57        return self._shape_tool         
     58   
     59    def get_color_tool(self): 
     60        return self._color_tool      
    4561         
    4662    def read_file(self):       
     
    4965        h_doc = TDocStd.Handle_TDocStd_Document() 
    5066        app = XCAFApp.GetApplication().GetObject() 
    51         app.NewDocument(TCollection.TCollection_ExtendedString("MDTV-CAF"),h_doc) 
     67        app.NewDocument(TCollection_ExtendedString("MDTV-CAF"),h_doc) 
    5268 
    5369 
     
    5975        shape_tool = h_shape_tool.GetObject() 
    6076        color_tool=h_colors_tool.GetObject() 
    61         self.color_tool=color_tool 
     77        self._color_tool=color_tool 
    6278         
    6379         
     
    6783        ColorLabels = TDF_LabelSequence() 
    6884        l=color_tool.BaseLabel() 
    69         print " La etiqueta base de color tool es : " , Nom_Label_Shape(l) 
    7085        color_tool.GetColors(ColorLabels) 
    7186 
    72         print 'Number of colors=%i'%ColorLabels.Length() 
    7387 
    7488 
     
    87101                if t.number_of_vertices() > 0: 
    88102                     
    89                     self._shapes_simples.append(simple_shape(Nom_Label_Shape(l_LabelShapes.Value(i+1)),compShape)) 
     103                    self._shapes_simples.append(simple_shape(GetLabelNom(l_LabelShapes.Value(i+1)),compShape)) 
    90104                else: 
    91                     print "Not information found for shape : ", Nom_Label_Shape(l_LabelShapes.Value(i+1)) 
     105                    print "Not information found for shape : ", GetLabelNom(l_LabelShapes.Value(i+1)) 
    92106           
    93          
     107 
     108 
     109 
     110       
    94111        #We are going to refill the tree with information 
     112        #comprobar aqui tambien que la cantidad es 1 
     113 
    95114        for i in range(l_Labels_root.Length()): 
    96  
    97             self._shapes_arbre.append(node_shape(Nom_Label_Shape(l_Labels_root.Value(i+1)),shape_tool.GetLocation(l_Labels_root.Value(i+1))))  
    98             parcours_recursif(l_Labels_root.Value(i+1),shape_tool,self._shapes_arbre[i].children,color_tool,self._shapes_simples) 
    99          
    100              
     115            nom=[GetLabelNom(l_Labels_root.Value(i+1))] 
     116            loc=[shape_tool.GetLocation(l_Labels_root.Value(i+1))] 
     117            labels=[l_Labels_root.Value(i+1)] 
     118            root=True 
     119            self._shapes_arbre.append(node_shape(nom,loc,labels,l_Labels_root.Value(i+1),root)) 
     120            parcours_recursif2(l_Labels_root.Value(i+1),shape_tool,self._shapes_arbre[i].children,color_tool,self._shapes_simples) 
     121 
     122        self._shape_tool=shape_tool 
    101123        return True               
    102124         
    103125 
    104 def parcours_recursif(label,shape_tool,arbre_shape,color_tool,shapes_simples): 
    105  
    106  
    107     #test 
    108      
    109  
     126 
     127 
     128def parcours_recursif2(label,shape_tool,arbre_shape,color_tool,shapes_simples):     
     129    """ 
    110130    l_SubShapes = TDF_LabelSequence() 
    111131    shape_tool.GetSubShapes(label,l_SubShapes) 
    112132    if(l_SubShapes.Length()>0): 
    113133        print "SubShapeDetectado ###################"#tengo un ejemplo en shapes con color 
    114     #/test 
    115  
    116          
     134    """ 
     135        
    117136    l_ComponentShapes = TDF_LabelSequence()  
    118137 
     138     
     139     
    119140    if(shape_tool.IsReference(label)):    
    120141        lab=TDF_Label() 
    121142        shape_tool.GetReferredShape(label,lab) 
    122143        shape_tool.GetComponents(lab,l_ComponentShapes) 
     144 
    123145    else: 
    124146        shape_tool.GetComponents(label,l_ComponentShapes) 
     
    126148 
    127149 
    128  
     150    #se podria hacer de una forma mas eficiente????? 
    129151    if(l_ComponentShapes.Length()>0): 
    130152 
     153        label_already_assigned=[] 
     154        #having count quantity 
     155        for i in range(l_ComponentShapes.Length()): 
     156            label_already_assigned.append(0) 
     157             
     158             
     159        index=0     
    131160        for f in range(l_ComponentShapes.Length()): 
    132             arbre_shape.append(node_shape(Nom_Label_Shape(l_ComponentShapes.Value(f+1)),shape_tool.GetLocation(label)))    
    133             parcours_recursif(l_ComponentShapes.Value(f+1),shape_tool,arbre_shape[f].children,color_tool,shapes_simples) 
     161         
     162            if not label_already_assigned[f]: 
     163                nom=[GetLabelNom(l_ComponentShapes.Value(f+1))] 
     164                location=[shape_tool.GetLocation(l_ComponentShapes.Value(f+1))] 
     165                labels=[l_ComponentShapes.Value(f+1)] 
     166                compShape=shape_tool.GetShape(l_ComponentShapes.Value(f+1)) 
     167                 
     168                for  t in range(f+1,l_ComponentShapes.Length()): 
     169                    if compShape.IsPartner(shape_tool.GetShape(l_ComponentShapes.Value(t+1))): 
     170                        label_already_assigned[t]=1 
     171                        nom.append(GetLabelNom(l_ComponentShapes.Value(t+1))) 
     172                        labels.append(l_ComponentShapes.Value(t+1)) 
     173                        location.append(shape_tool.GetLocation(l_ComponentShapes.Value(t+1))) 
     174 
     175                     
     176            #modificacion para anadir varias locaciones y cantidad 
     177                #arbre_shape.append(node_shape(GetLabelNom(l_ComponentShapes.Value(f+1)),shape_tool.GetLocation(label))) 
     178                # y si es referencia cojo el nombre de la referencia para tener uno unificado 
     179                if(shape_tool.IsReference(l_ComponentShapes.Value(f+1))): 
     180                    lab=TDF_Label() 
     181                    shape_tool.GetReferredShape(l_ComponentShapes.Value(f+1),lab)  
     182                    nom_component=GetLabelNom(lab) 
     183                else: 
     184                    nom_component=GetLabelNom(l_ComponentShapes.Value(f+1)) 
     185                    lab=l_ComponentShapes.Value(f+1) 
     186                    
     187                arbre_shape.append(node_shape(nom,location,labels,l_ComponentShapes.Value(f+1),nom_component))    
     188                parcours_recursif2(l_ComponentShapes.Value(f+1),shape_tool,arbre_shape[index].children,color_tool,shapes_simples) 
     189                index=index+1 
     190 
    134191    else: 
    135192     
     
    138195        for s in range(len(shapes_simples)): 
    139196            if compShape.IsPartner(shapes_simples[s].shape): 
    140                 arbre_shape.append(feuille_nom_shapes(Nom_Label_Shape(label),shape_tool.GetLocation(label),colour_chercher(label,color_tool,shape_tool),s))  
     197                arbre_shape.append(feuille_nom_shapes(GetLabelNom(label),colour_chercher(label,color_tool,shape_tool),s))  
    141198                break 
    142199        #else: 
    143200 
    144201         
    145 def Nom_Label_Shape(lab): 
    146  
    147             entry = TCollection.TCollection_AsciiString() 
     202     
     203 
     204 
     205 
     206    """ 
     207    l_SubShapes = TDF_LabelSequence() 
     208    shape_tool.GetSubShapes(label,l_SubShapes) 
     209    if(l_SubShapes.Length()>0): 
     210        print "SubShapeDetectado ###################"#tengo un ejemplo en shapes con color 
     211    """ 
     212        
     213 
     214 
     215     
     216     
     217  
     218 
     219         
     220def GetLabelNom(lab): 
     221 
     222            entry = TCollection_AsciiString() 
    148223            TDF_Tool.Entry(lab,entry) 
    149224            N = Handle_TDataStd_Name() 
     
    151226            n=N.GetObject() 
    152227            return n.Get().PrintToString() 
    153   
    154   
     228 #p=TCollection_AsciiString("jota") 
     229def SetLabelNom(lab,nom): 
     230 
     231    entry = TCollection_AsciiString() 
     232    TDF_Tool.Entry(lab,entry) 
     233    N = Handle_TDataStd_Name() 
     234    lab.FindAttribute(TDataStd_Name_GetID(),N) 
     235    n=N.GetObject() 
     236    n.Set(TCollection_ExtendedString(nom)) 
     237    return True 
    155238  
    156239 
     
    161244    c=Quantity_Color() 
    162245    if( color_tool.GetInstanceColor(shape_tool.GetShape(label),0,c) or  color_tool.GetInstanceColor(shape_tool.GetShape(label),1,c) or color_tool.GetInstanceColor(shape_tool.GetShape(label),2,c)): 
    163         #print "Color (",c.Red(),",",c.Green() ,"," ,c.Blue() ,    ") encontrado para : " , Nom_Label_Shape(label)  
     246        color_tool.SetColor(label,c,0) 
     247        color_tool.SetColor(label,c,1) 
     248        color_tool.SetColor(label,c,2) 
     249        print "Color encontrado manera 1(",c.Red(),",",c.Green() ,"," ,c.Blue() ,    ") encontrado para : " , GetLabelNom(label)  
    164250        return c 
    165     else: 
    166         return False 
     251     
     252    if( color_tool.GetColor(label,0,c) or  color_tool.GetColor(label,1,c) or color_tool.GetColor(label,2,c) ): 
     253        print "Color encontrado manera 2 (",c.Red(),",",c.Green() ,"," ,c.Blue() ,    ") encontrado para : " , GetLabelNom(label)  
     254        return c 
     255 
     256    return False 
    167257                    
    168258 
    169259 
    170  
  • branches/3D/openPLM/document3D/aficher.py

    r613 r644  
    33from openPLM.document3D.models import * 
    44from openPLM.document3D.Mesh import * 
     5from openPLM.document3D.composer import * 
     6from openPLM.document3D.decomposer import * 
    57from kjbuckets import kjGraph 
    68from OCC.TopLoc import TopLoc_Location 
    7  
     9from OCC.Utils.DataExchange.STEP import StepOCAF_Export 
     10from django.core.files import File 
     11from OCC.TDF import * 
    812 
    913import time 
    10  
     14#importante, voy a eliminar tmb los shapes referenciados, es esto u problema? 
     15#hqcer unq pruebq q mqno pqrq verificqrlo 
    1116        
    12 def convertir_STP_to_WebGL(doc_file): 
     17def convertir_STP_to_WebGL(doc_file,controller): 
    1318 
    1419 
     
    1722    my_step_importer.read_file() 
    1823 
    19  
    20  
    21     fileName, fileExtension = os.path.splitext(doc_file.filename)  
    22     my_shapes_arbre = my_step_importer.get_shapes_arbre() 
    23     my_shapes_simples = my_step_importer.get_shapes_simples() 
    24     init_time = time.time() 
    2524     
    26  
     25    
     26    procesing_simples_shapes(my_step_importer.get_shapes_simples(),doc_file) 
    2727     
    28     for i, shape in enumerate(my_shapes_simples): 
    29             new_stp_jss= stp_to_jss() 
    30             new_stp_jss.stp = doc_file 
    31             # new_stp_jss.save() 
    32             print "processing mesh " ,shape.nom ,   " " , i+1 , "/" ,len(my_shapes_simples) 
    33             my_mesh = mesh_shape(shape.shape) 
    34   
    35             name = new_stp_jss.js.storage.get_available_name(fileName+".js") 
    36             path = os.path.join(new_stp_jss.js.storage.location, name) 
    37              
    38             if(not mesh_to_3js(my_mesh,path.encode(),"_"+str(i))): 
    39                 #pour statistique 
    40                 #triangles=my_mesh. 
    41                 # new_stp_jss.delete() 
    42                 print "Error generating fichier .JS for shape : " ,shape.nom  
    43                 return False     
    44                 #exception 
    45             else: 
    46  
    47                 new_stp_jss.js = name 
    48                 new_stp_jss.save() 
    49                  
    50     print '\n\nFinisehd computation of all shapes in %fs'%(time.time()-init_time) 
    51  
    52  
    53     ###     Remplir my_shape avec information sur vertex, faces et graph avec l' arbre de nom de parts, root avec nom de parts roots. 
    54     graph=kjGraph() 
    55  
    56     root=[] 
    57     part_numeration=[0] 
    58     objects_numeration=[0] 
    59     menu_generate_objects=["var object3D = new THREE.Object3D();\n"] 
    60     for i in range(len(my_shapes_arbre)): 
    61         loc=[] 
    62         nom=my_shapes_arbre[i].nom+"."+str(part_numeration[0]) 
    63         root.append(nom) 
    64         ok=parcours_recursif(my_shapes_arbre[i],graph,part_numeration,menu_generate_objects,objects_numeration,loc,nom,True) 
    65  
    66     ### 
    67      
    68      
    69  
    70     new_stp_to_jss_arborescense= stp_to_jss_arborescense() 
    71     new_stp_to_jss_arborescense.stp = doc_file 
    72     name = new_stp_to_jss_arborescense.js.storage.get_available_name(fileName+".js") 
    73     path = os.path.join(new_stp_to_jss_arborescense.js.storage.location, name) 
    74     new_stp_to_jss_arborescense.js = name 
    75     new_stp_to_jss_arborescense.save() 
    76      
    77     if ok: 
    78         try: 
    79             directory = os.path.dirname(path.encode())         
    80             if not os.path.exists(directory): 
    81                 os.makedirs(directory) 
    82                  
    83                
    84             output = open(path.encode(),"w") 
    85              
    86              
    87             ######          Generate Menu javascript and objects         
    88             output.write("function menu() {\nelement = document.createElement(\"div\");\nelement.id=\"root\";\nelement.innerHTML =\"")         
    89             generate_menu(graph,root,output)   
    90             output.write("\";\ndocument.getElementById('menu_').appendChild(element);\n}\n") 
    91             ######          End generate menu 
    92              
    93              
    94             #####           Generate objects javascript 
    95             output.write(menu_generate_objects[0]) 
    96             #####           End generate objects 
    97              
    98                      
    99             #####           Generate functions javascript 
    100             generate_functions(graph,root,output) 
    101             #####           End generate functions 
    102              
    103              
    104  
    105                     
    106             output.close()  
    107              
    108         except IOError as (errno, strerror): 
    109             print "I/O error({0}): {1}".format(errno, strerror) 
    110             return False 
    111     return ok 
    112  
    113      
    114   
    115 function_change_part_head = """ 
    116 function change_part%(part_id)s(atribute) { 
    117     if (atribute==\"click\"){ 
    118      
    119         part%(part_id)s.visible=!part%(part_id)s.visible; 
    120          
    121     } 
    122     else{ 
    123         part%(part_id)s.visible=atribute; 
    124     } 
    125          
    126 """  
    127 function_change_part = """ 
    128     change_part%(part_id_2)s(part%(part_id)s.visible)        
    129 """ 
    130 function_change_object = """ 
    131     object%(object_id)s.visible=part%(part_id)s.visible;    
    132 """                                     
    133            
    134 def generate_functions(graph,root,output,nom=''): 
    135  
    136  
    137     if not nom=='': #nom = '' only in first interaction 
    138         root=graph.neighbors(nom) 
    139  
    140     for i in range(len(root)): 
    141   
    142          
    143         feuille=graph.neighbors(root[i]) 
    144         if not len(feuille)==0:  
    145             part_name, part_id = os.path.splitext(root[i]) 
    146             part_id=part_id.replace(".","") 
    147             output.write(function_change_part_head % (locals()))  
    148  
    149             for t in range(len(feuille)): 
    150                 feuille_2=graph.neighbors(feuille[t]) 
    151                  
    152                 if feuille_2: 
    153                     part_name, part_id_2 = os.path.splitext(feuille[t]) 
    154                     part_id_2=part_id_2.replace(".","") 
    155                     output.write(function_change_part % (locals()))     
    156                 else: 
    157                     if "." not in str(feuille[t]):  # para evitar generar objetos de instances arbresnom que no tienen hijos se puede dar el caso de shape sin informacion que no van a generar hijos 
    158                         object_id=feuille[t] 
    159                         output.write(function_change_object % (locals()))  
    160        
    161   
    162              
    163  
    164             output.write("}\n") 
    165             generate_functions(graph,'',output,root[i]) 
    166  
    167  
    168   
    169 function_generate_menu= """ 
    170     
    171 <li > <a href='#' onClick='change_part%(part_id)s(\\"click\\")'><b onClick='change_part%(part_id)s(\"click\")'></b>%(part_name)s </a>    
    172     
    173 """  
    174 def generate_menu(graph,root,output,nom=''): 
    175  
    176  
    177  
    178     output.write("<ul>")     
    179      
    180     if not nom=='': #nom = '' only in first interaction 
    181         root=graph.neighbors(nom) 
    182  
    183     for i in range(len(root)): 
    184   
    185         feuille=graph.neighbors(root[i]) 
    186         if not len(feuille)==0:  
    187             part_name, part_extension = os.path.splitext(root[i]) 
    188             part_id=part_extension.replace(".","") 
    189             output.write(function_generate_menu % (locals()))  
    190             """ 
    191             functio_onclick="change_part"+part_id+"(\\\"click\\\")" 
    192             output.write("<li > <a href='#' onClick='%s'><b onClick='%s'></b>%s </a>"%(functio_onclick,functio_onclick,part_name)) 
    193             """            
    194             generate_menu(graph,'',output,root[i])        
    195             output.write("</li>") 
    196  
    197     
    198     output.write("</ul>") 
    199  
    200   
    201 function_generate_objects= """ 
    202  
    203 var NewMaterial=new THREE.MeshBasicMaterial({opacity:0.2,shading:THREE.SmoothShading}); 
    204 NewMaterial.color.setRGB(%(red)f,%(green)f,%(blue)f); 
    205 var object%(numeration)s=new THREE.Mesh( new _%(reference)s(),NewMaterial ); 
    206 object3D.add(object%(numeration)s);         
    207 """    
    208 #el grafo para las partes tiene el nombre .id correlativa, para las hojas es directamente un ID             
    209 def parcours_recursif(my_shapes_arbre,graph,part_numeration,menu_generate_objects,objects_numeration,loc,old_name,root=False): 
    210      
    211      
    212     if  isinstance(my_shapes_arbre,node_shape): 
    213         loc.append(my_shapes_arbre.loc)  
    214  
    215         if not root: 
    216             nom=my_shapes_arbre.nom 
    217             nom=nom+"."+str(part_numeration[0]) 
    218             graph.add(old_name,nom) 
    219         else: 
    220             nom=old_name 
    221              
    222         menu_generate_objects[0]+="var part%s=new THREE.Object3D();\n"%part_numeration[0] 
    223         part_numeration[0]=part_numeration[0]+1 
    224          
    225         for i in range(len(my_shapes_arbre.children)): 
    226          
    227             parcours_recursif(my_shapes_arbre.children[i],graph,part_numeration,menu_generate_objects,objects_numeration,loc[:],nom) 
    228              
    229              
    230              
    231     else: #is instance of feuille_nom_shapes 
    232     #var mesh = new THREE.Mesh( geometry, new THREE.MeshBasicMaterial( { color: 0xffffff } )  ); 
    233         numeration=objects_numeration[0] 
    234         red=my_shapes_arbre.red 
    235         green=my_shapes_arbre.green 
    236         blue=my_shapes_arbre.blue 
    237         reference=my_shapes_arbre.reference 
    238         menu_generate_objects[0]+=str(function_generate_objects % (locals())) 
    239  
    240             #hacer las translaciones 
    241         if isinstance(my_shapes_arbre.loc,TopLoc_Location):      
    242             loc.append(my_shapes_arbre.loc)  
    243          
    244          
    245          
    246         if len(loc)>0: 
    247             transformation=gp_Trsf() 
    248             gp=gp_XYZ() 
    249             for g in range(len(loc)): 
    250                 if g==0: 
    251                     transformation=loc[g].Transformation() 
    252                 else: 
    253                     transformation.Multiply(loc[g].Transformation()) 
    254                      
    255             a ,b =transformation.GetRotation(gp) 
    256             t=transformation.TranslationPart() 
    257             if a:         
    258                 menu_generate_objects[0]+="object%s.matrix.setRotationAxis(new THREE.Vector3( %s, %s, %s ), %s);\n"%(objects_numeration[0],gp.X(),gp.Y(),gp.Z(),b) 
    259                  
    260             menu_generate_objects[0]+="object%s.matrix.setPosition(new THREE.Vector3( %s, %s, %s ));\n"%(objects_numeration[0],t.X(),t.Y(),t.Z()) 
    261             menu_generate_objects[0]+="object%s.matrixAutoUpdate = false;\n"%objects_numeration[0] 
    262              
    263              
    264         graph.add(old_name,objects_numeration[0]) 
    265         objects_numeration[0]=objects_numeration[0]+1 
    266                    
    267     return True          
    26828 
    26929 
    27030     
    271 def mesh_shape(shape): 
    272     """ Take a topods_shape instance, returns the tesselated object""" 
    273     ''' Connect a ode.Trimesh to this body. The mesh is generated from the MSH subpackage. vertices lits 
    274     and faces indices are passed to the trimesh. 
    275     The default mesh precision is divided by the quality factor: 
    276     - if quality_factor>1, the mesh will be more precise, i.e. more triangles (more precision, but also 
    277     more memory consumption and time for the mesher, 
    278     - if quality_factor<1, the mesh will be less precise. 
    279     By default, this argument is set to 1 : the default precision of the mesher is used. 
    280     ''' 
    281     quality_factor=1 
    282     a_mesh = QuickTriangleMesh(DISPLAY_LIST=True) 
    283     a_mesh.set_shape(shape) 
    284     a_mesh.set_precision(a_mesh.get_precision()/quality_factor) 
    285     a_mesh.compute() 
    286     return a_mesh        
     31    part_numeration , objects_numeration = generate_file_arborescense(my_step_importer.get_shapes_arbre(),doc_file) 
    28732 
     33    new_doc_file=decomposer(my_step_importer.get_shapes_tool(),my_step_importer.get_shapes_arbre(),controller,doc_file,part_numeration,objects_numeration) 
    28834 
    28935 
    29036 
    29137     
    292 def mesh_to_3js(mesh,filename,name): 
    293     """ Take a mesh, exports to a three.js javascript file""" 
     38 
     39    composer(my_step_importer.get_shapes_arbre(),new_doc_file)          
     40    print "\n\n\nTermina saliendo BIEN y CoRrecTo\n\n\n"    
     41    return ok 
     42 
    29443 
    29544 
    29645     
    297     try: 
    298         directory = os.path.dirname(filename) 
    299          
    300         if not os.path.exists(directory): 
    301             os.makedirs(directory) 
    30246 
    303         output = open(filename,"w") 
    304         output.write(""" 
    305     var %s = function () { 
    306  
    307     var scope = this; 
    308     THREE.Geometry.call( this ); 
    309         """%name) 
    310         # export vertices 
    311         for vertex in mesh.get_vertices(): 
    312  
    313            output.write('v(%.4f,%.4f,%.4f);\n'%(vertex[0],vertex[1],vertex[2])) 
    314         # export faces 
    315         index = 0 
    316         faces = mesh.get_faces() 
    317         normals = mesh.get_normals() 
    318         while index<len(faces)-2: 
    319             n1 = normals[index] 
    320             n2 = normals[index+1] 
    321             n3 = normals[index+2] 
    322             output.write('f3(%i,%i,%i,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f);\n'%(faces[index],faces[index+1],faces[index+2],n1[0],n1[1],n1[2],n2[0],n2[1],n2[2],n3[0],n3[1],n3[2])) 
    323              
    324             index += 3 
    325          
    326         #closing file 
    327         #this.sortFacesByMaterial(); 
    328         output.write(""" 
    329      
    330     function v( x, y, z ) { 
    331         scope.vertices.push( new THREE.Vertex( new THREE.Vector3( x, y, z )  ) ); 
    332         } 
    333     function f3( a, b, c, n1_x,n1_y,n1_z,n2_x,n2_y,n2_z,n3_x,n3_y,n3_z ) { 
    334         scope.faces.push( new THREE.Face3( a, b, c, [ new THREE.Vector3( n1_x, n1_y, n1_z ), new THREE.Vector3( n2_x, n2_y, n2_z ), new THREE.Vector3( n3_x, n3_y, n3_z ) ]  ) ); 
    335         } 
    336         } 
    337  
    338     %s.prototype = new THREE.Geometry(); 
    339     %s.prototype.constructor = %s; 
    340         """%(name,name,name)) 
    341         output.close() 
    342         return True 
    343     except IOError as (errno, strerror): 
    344         print "I/O error({0}): {1}".format(errno, strerror) 
    345         return False 
    34647         
    34748 
  • branches/3D/openPLM/document3D/models.py

    r613 r644  
    5555    """ 
    5656    js = models.FileField(upload_to='.',storage=media3Djs) 
    57     stp = models.ForeignKey(DocumentFile)     
     57    stp = models.ForeignKey(DocumentFile) 
     58    index = models.IntegerField() 
    5859 
    5960 
     
    7475        self.nom = nom 
    7576        self.shape = shape 
    76 #Representation d un node non feuille dans l arborescence du fichier step 
    77 #nom: nom du composant 
    78 #children: list d'enfants 
    79 #loc: garde la localisation du composan (si le composant n'est pas une reference a autre composant, la localisation va etre la matrix Identity) 
    80 class node_shape(): 
     77         
     78class part_reference(object): 
     79 
     80    __slots__ = ("nom", "loc", "quantity","labels") 
     81     
     82     
     83    def __init__(self, nom,location,step_ref): 
     84        self.nom = nom 
     85        self.loc = location 
     86        self.quantity=len(nom) 
     87        self.step_ref=step_ref 
     88 
     89#la referencia deberia ser un nombre de fichero o un docfile completo? 
     90class node_shape(object): 
    8191    u""" 
    8292    Representation of a node (component) not leaf in the arborescense of the file STEP 
     
    96106 
    97107    """ 
    98     nom='' 
    99     children=[] 
    100     loc=TopLoc_Location() 
    101     def __init__(self, nom,location=''): 
     108    __slots__ = ("nom", "loc", "children", "quantity","labels","path","root","label_ref","ref_id","nom_component") 
     109     
     110     
     111    def __init__(self, nom,location,labels,label_ref,nom_component,root=False,path=False): 
    102112        self.nom = nom 
    103113        self.children=[] 
    104114        self.loc = location 
    105 #Representation d une feuille dans l arborescence du fichier step qui contient information geometric 
    106 #nom: nom du composant 
    107 #loc: garde la localisation du composan (si le composant n est pas une reference a autre composant, la localisation va etre la matrix Identity) 
    108 #ref: pendent la generation de fichiers step nous allons remplir un vecteur de toutes differentes geometrie simples (simple_shape) ,il indique l indice dans le vecteur qui correspond a la geometrie   
    109 class feuille_nom_shapes(): 
     115        self.labels = labels 
     116        self.quantity=len(nom) 
     117        self.path=path 
     118        self.root=root 
     119        self.nom_component=nom_component 
     120        self.label_ref=label_ref # para meter la referencia y asi tener componentes 
     121         
     122    def IsReference(self): 
     123        return self.path 
     124    def IsRoot(self): 
     125        return self.root 
     126         
     127          
     128class feuille_nom_shapes(object): 
    110129    u""" 
    111130    Representation of a leaf (shape geometry) in the arborescense of the file STEP,this representation is not direct, stores a reference that allows to obtain the    geometry 
     
    117136        .. attribute:: reference 
    118137 
    119             During the treatment of files STEP we are going to generate a vector with all the different simple geometries, this reference is an entire number that indicates the index inside the vector where we will find the geometry (more ahead it will be necessarily to combine the locations to place the geometry in the space)     
     138            During the treatment of files STEP we are going to generate a vector with all the different simple geometries, this reference is an entire number that    indicates the index inside the vector where we will find the geometry (more ahead it will be necessarily to combine the locations to place the geometry in the space)     
    120139         
    121140        .. attribute:: loc 
     
    136155 
    137156    """ 
    138     nom='' 
    139     loc=TopLoc_Location() 
    140     reference='' 
    141     red=0 
    142     green=0 
    143     blue=0 
    144     def __init__(self, nom,location,colour,ref): 
    145         self.nom = nom 
    146         self.loc = location 
     157     
     158    __slots__ = ("nom", "reference", "red", "green", "blue") 
     159     
     160    def __init__(self, nom,colour,ref): 
     161        self.nom = nom 
    147162        self.reference=ref 
    148163        if colour: 
     
    150165            self.green=colour.Green() 
    151166            self.blue=colour.Blue() 
     167        else: 
     168            self.red = self.green = self.blue = 0 
    152169 
    153170from celery.task import task 
    154171@task 
    155 def handle_step_file(doc_file_pk): 
     172def handle_step_file(doc_file_pk,controller): 
    156173    doc_file = DocumentFile.objects.get(pk=doc_file_pk) 
    157174    from openPLM.document3D.aficher import convertir_STP_to_WebGL 
    158175         
    159176    fileName, fileExtension = os.path.splitext(doc_file.filename) 
    160     if fileExtension.upper() in ('.STP', '.STEP'):          
    161         eliminer_associes(doc_file) 
    162         ok=convertir_STP_to_WebGL(doc_file) 
     177    if fileExtension.upper() in ('.STP', '.STEP'): 
     178        query_jss=stp_to_jss.objects.filter(stp=doc_file) 
     179        files_js=list(query_jss.values_list("js", flat=True)) 
     180        query_jss=stp_to_jss_arborescense.objects.filter(stp=doc_file) 
     181        arborescense_js=list(query_jss.values_list("js", flat=True))  
     182        #neccesary in case of check-in           
     183        eliminer_associes(files_js,arborescense_js) 
     184        ok=convertir_STP_to_WebGL(doc_file,controller) 
    163185         
    164186        if not ok: 
     
    167189            print "Error: It was not possible to generate a sight 3D of the file." 
    168190            return False             
    169  
    170             return True             
     191         
     192         
     193            return True 
     194             
     195                         
     196 
     197 
     198     
     199 
     200 
     201 
    171202 
    172203class Document3DController(DocumentController): 
    173204 
    174205    def handle_added_file(self, doc_file): 
    175         handle_step_file.delay(doc_file.pk)         
     206     
     207        handle_step_file.delay(doc_file.pk,self)         
    176208             
    177209    def delete_file(self, doc_file): 
    178210     
    179211        fileName, fileExtension = os.path.splitext(doc_file.filename) 
    180         if fileExtension.upper() in ('.STP', '.STEP'):  
    181             eliminer_associes(doc_file) 
     212 
     213        if fileExtension.upper() in ('.STP', '.STEP'): 
     214            query_jss=stp_to_jss.objects.filter(stp=doc_file) 
     215            files_js=list(query_jss.values_list("js", flat=True)) 
     216            query_jss=stp_to_jss_arborescense.objects.filter(stp=doc_file) 
     217            arborescense_js=list(query_jss.values_list("js", flat=True))   
     218                       
    182219        super(Document3DController, self).delete_file(doc_file) 
    183  
    184  
     220        #il faut apeller super avant pour verifier droits de utilisateur 
     221         
     222        if fileExtension.upper() in ('.STP', '.STEP'): 
     223            eliminer_associes(files_js,arborescense_js) 
    185224 
    186225 
    187226#elimine les fichiers .jss associes a un fichier step  
    188227 
    189 def eliminer_associes(doc_file): 
    190  
    191     query_jss=stp_to_jss.objects.filter(stp=doc_file) 
    192     files_js=query_jss.values_list("js", flat=True) 
     228def eliminer_associes(files_js,arborescense_js): 
     229 
     230 
    193231    for name in files_js: 
    194232        filename = settings.MEDIA_ROOT+"3D/"+ name 
     
    196234            os.remove(filename) 
    197235            print "Deleting geometry .jss associes:" , filename 
    198     query_jss.delete()     
    199  
    200     query_jss=stp_to_jss_arborescense.objects.filter(stp=doc_file) 
    201     navigabilite_js=query_jss.values_list("js", flat=True) 
    202     for name in navigabilite_js: 
     236 
     237    for name in arborescense_js: 
    203238        filename = settings.MEDIA_ROOT+"3D/arborescence/"+name 
    204239        if os.path.exists(filename) and os.path.isfile(filename): 
    205240            os.remove(filename) 
    206241            print "Deleting arborescence .jss associe:" , filename 
    207     query_jss.delete() 
    208  
     242 
     243 
  • branches/3D/openPLM/document3D/views.py

    r613 r644  
    5050            if multi_image.count()>0: 
    5151                menu_arborescense=stp_to_jss_arborescense.objects.filter(stp=image)[0].js.name 
    52             else:     
     52            else: 
     53                #menu_arborescense=stp_to_jss_arborescense.objects.filter(stp=image)[0].js.name     
    5354                menu_arborescense="" 
    5455 
Note: See TracChangeset for help on using the changeset viewer.