Esempio n. 1
0
 def slices_ray_intersection(self,near,far,center):        
     bx,by,bz=self.data.shape
     point=None
     #x plane
     px0=[self.x,-by/2.,-bz/2.]
     px1=[self.x,-by/2., bz/2.]
     px2=[self.x, by/2., bz/2.]
     success_x,dist_x,point_x = cll.intersect_segment_plane(near,far,px0,px1,px2)
     print 'success_x',success_x, 'dist x:',dist_x, 'point x', point_x            
     if success_x:
         if point_x[1]>=px0[1] and point_x[1]<=px2[1] and point_x[2]>=px0[2] and point_x[2]<=px2[2]:                        
             success_x=True                                                                                      
         else:
             success_x=False
     #y plane
     py0=[-bx/2.,self.y,-bz/2.]
     py1=[-bx/2.,self.y, bz/2.]
     py2=[ bx/2.,self.y, bz/2.]
     success_y,dist_y,point_y = cll.intersect_segment_plane(near,far,py0,py1,py2)
     #print 'dist y:',dist_y
     print 'success_y',success_y, 'dist y:',dist_y, 'point y', point_y
     if success_y:
         if point_y[0]>=py0[0] and point_y[0]<=py2[0] and point_y[2]>=py0[2] and point_y[2]<=py2[2]:                        
             success_y=True                                                                                      
         else:
             success_y=False
     #z plane
     pz0=[-bx/2.,-by/2.,self.z]
     pz1=[-bx/2., by/2.,self.z]
     pz2=[ bx/2., by/2.,self.z]
     success_z,dist_z,point_z = cll.intersect_segment_plane(near,far,pz0,pz1,pz2)            
     #print 'dist z:',dist_z
     print 'success_z',success_z, 'dist z:',dist_z, 'point z', point_z
     if success_z:
         if point_z[0]>=pz0[0] and point_z[0]<=pz2[0] and point_z[1]>=pz0[1] and point_z[1]<=pz2[1]:                        
             success_z=True                                                                                      
         else:
             success_z=False        
     if dist_x==None:
         dist_x=np.finfo(np.float64)
     if dist_y==None:
         dist_y=np.finfo(np.float64)
     if dist_z==None:
         dist_z=np.finfo(np.float64)        
     #check nearest
     if success_x:
         if dist_x < dist_y and dist_x < dist_z: 
             return point_x
     if success_y:
         if dist_y < dist_x and dist_y < dist_z: 
             return point_y
     if success_z:
         if dist_z < dist_x and dist_z < dist_y: 
             return point_z
     return None            
Esempio n. 2
0
    def process_pickray(self,near,far):
        #collision with plane
 
        success,t,p= cll.intersect_segment_plane(near,far,self.p0,self.p1,self.p2)

        print success
        print p

        o0_low_left=(-self.spri.width-self.sprj.width/2.,-self.spri.height/2)
        o0_up_right= (-self.sprj.width/2.,self.spri.height/2)       
        if tell_me_if(p,o0_low_left,o0_up_right):
            print 'Object 0'
            pix0=np.round(p[0]-o0_low_left[0]).astype(int)
            pix1=np.round(p[1]-o0_low_left[1]).astype(int)            
            self.update_vox_coords(self.vxi,pix1,pix0)            
            print 'Changed', self.vxi,pix0,pix1            
 
        o1_low_left=(-self.sprj.width/2.,-self.sprj.height/2)
        o1_up_right= (self.sprj.width/2.,self.sprj.height/2)               
        if tell_me_if(p,o1_low_left,o1_up_right):
            print 'Object 1'
            pix0=np.round(p[0]-o1_low_left[0]).astype(int)
            pix1=np.round(p[1]-o1_low_left[1]).astype(int)
            self.update_vox_coords(pix1,self.vxj,pix0)            
            

        o2_low_left=(self.sprj.width/2.,-self.sprk.height/2)
        o2_up_right= (self.sprj.width/2+self.sprk.width,self.spri.height/2)       
        if tell_me_if(p,o2_low_left,o2_up_right):
            print 'Object 2'
            pix0=np.round(p[0]-o2_low_left[0]).astype(int)
            pix1=np.round(p[1]-o2_low_left[1]).astype(int)
            self.update_vox_coords(pix1,pix0,self.vxk)
         
        print np.round(p)
Esempio n. 3
0
    def process_pickray(self,near,far):
        #collision with plane
 
        success,t,p= cll.intersect_segment_plane(near,far,self.p0,self.p1,self.p2)

        print success
        print p

        o0_low_left=(-self.spri.width-self.sprj.width/2.,-self.spri.height/2)
        o0_up_right= (-self.sprj.width/2.,self.spri.height/2)       
        if tell_me_if(p,o0_low_left,o0_up_right):
            print 'Object 0'
            pix0=np.round(p[0]-o0_low_left[0]).astype(int)
            pix1=np.round(p[1]-o0_low_left[1]).astype(int)            
            self.update_vox_coords(self.vxi,pix1,pix0)            
            print 'Changed', self.vxi,pix0,pix1            
 
        o1_low_left=(-self.sprj.width/2.,-self.sprj.height/2)
        o1_up_right= (self.sprj.width/2.,self.sprj.height/2)               
        if tell_me_if(p,o1_low_left,o1_up_right):
            print 'Object 1'
            pix0=np.round(p[0]-o1_low_left[0]).astype(int)
            pix1=np.round(p[1]-o1_low_left[1]).astype(int)
            self.update_vox_coords(pix1,self.vxj,pix0)            
            

        o2_low_left=(self.sprj.width/2.,-self.sprk.height/2)
        o2_up_right= (self.sprj.width/2+self.sprk.width,self.spri.height/2)       
        if tell_me_if(p,o2_low_left,o2_up_right):
            print 'Object 2'
            pix0=np.round(p[0]-o2_low_left[0]).astype(int)
            pix1=np.round(p[1]-o2_low_left[1]).astype(int)
            self.update_vox_coords(pix1,pix0,self.vxk)
         
        print np.round(p)
Esempio n. 4
0
  def process_keys(self,symbol,modifiers):
      
      if symbol == key.P:
          x,y=self.mouse_x,self.mouse_y
          nx,ny,nz=screen_to_model(x,y,0)
          fx,fy,fz=screen_to_model(x,y,1)        
          near=(nx,ny,nz)
          far=(fx,fy,fz)          
          print 'P'   
          #print 'collision with plane' 
          success,t,p= cll.intersect_segment_plane(near,far,self.p0,self.p1,self.p2)
          print success
          print p
  
          o0_low_left=(-self.spri.width-self.sprj.width/2.,-self.spri.height/2)
          o0_up_right= (-self.sprj.width/2.,self.spri.height/2)       
          if tell_me_if(p,o0_low_left,o0_up_right):
              print 'Object 0'
              pix0=np.round(p[0]-o0_low_left[0]).astype(int)
              pix1=np.round(p[1]-o0_low_left[1]).astype(int)            
              self.update_vox_coords(self.vxi,pix1,pix0)            
              print 'Changed', self.vxi,pix0,pix1     
          o1_low_left=(-self.sprj.width/2.,-self.sprj.height/2)
          o1_up_right= (self.sprj.width/2.,self.sprj.height/2)               
          if tell_me_if(p,o1_low_left,o1_up_right):
              print 'Object 1'
              pix0=np.round(p[0]-o1_low_left[0]).astype(int)
              pix1=np.round(p[1]-o1_low_left[1]).astype(int)
              self.update_vox_coords(pix1,self.vxj,pix0)            
 
          o2_low_left=(self.sprj.width/2.,-self.sprk.height/2)
          o2_up_right= (self.sprj.width/2+self.sprk.width,self.spri.height/2)       
          if tell_me_if(p,o2_low_left,o2_up_right):
              print 'Object 2'
              pix0=np.round(p[0]-o2_low_left[0]).astype(int)
              pix1=np.round(p[1]-o2_low_left[1]).astype(int)
              self.update_vox_coords(pix1,pix0,self.vxk)
Esempio n. 5
0
    def break_bundle(self,tracks, p1, p2, p3):


        import fos.core.collision as cll

        tracksa=[]

        tracksb=[]

        for t in tracks:

            for i in range(len(t)-1):

                success, per, p = cll.intersect_segment_plane(t[i],t[i+1], p1, p2, p3)

                if success:

                    #print t, i

                    tracksa.append(t[:i-1])

                    tracksb.append(t[i+1:-1])

        return tracksa, tracksb