Esempio n. 1
0
 def use_bounding_box(self):
     bbox = get_boundingbox(self._shape, EPSILON)
     xmin, ymin, zmin, xmax, ymax, zmax = bbox.Get()
     dx, dy, dz = xmax - xmin, ymax - ymin, zmax - zmin
     self._collision_geometry = ode.GeomBox(self._space,
                                            lengths=(dx, dy, dz))
     self._collision_geometry.setBody(self)
Esempio n. 2
0
 def use_sphere(self):
     """ Connect a ode.GeomSphere to the body
     The sphere radius is computed as the mean of the bounding box dimensions. As a consequence,
     if the TopoDS_Shape is a sphere, then the radius of the ode.GeomSphere will be the radius
     of the sphere
     """
     xmin, ymin, zmin, xmax, ymax, zmax = get_boundingbox(self._shape, EPSILON)
     dx, dy, dz = xmax - xmin, ymax - ymin, zmax - zmin
     r = (dx + dy + dz) / 6.0  # /3 gives the mean diameter, so divide by 2 for the radius
     self._collision_geometry = ode.GeomSphere(self._space, radius=r)
     self._collision_geometry.setBody(self)
Esempio n. 3
0
 def use_sphere(self):
     ''' Connect a ode.GeomSphere to the body
     The sphere radius is computed as the mean of the bounding box dimensions. As a consequence,
     if the TopoDS_Shape is a sphere, then the radius of the ode.GeomSphere will be the radius
     of the sphere
     '''
     bbox = get_boundingbox(self._shape, EPSILON)
     xmin, ymin, zmin, xmax, ymax, zmax = bbox.Get()
     dx, dy, dz = xmax - xmin, ymax - ymin, zmax - zmin
     r = (
         dx + dy + dz
     ) / 6.  # /3 gives the mean diameter, so divide by 2 for the radius
     self._collision_geometry = ode.GeomSphere(self._space, radius=r)
     self._collision_geometry.setBody(self)
Esempio n. 4
0
def run( n_procs, compare_by_number_of_processors=False ):

    shape = get_brep()
    x_min, y_min, z_min, x_max, y_max, z_max = get_boundingbox(shape)
    z_delta = abs( z_min - z_max )

    # compute bounding box!
    init_time = time.time() # for total time computation
    

    def get_z_coords_for_n_procs(n_slices, n_procs):
        z_slices = numpy.arange( z_min, z_max, z_delta/n_slices )
        
        slices = []
        n = z_slices.shape[0] / n_procs
        
        _str_slices = []
        for i in range(1, n_procs+1):
            if i == 1:
                slices.append(z_slices[ :i*n ].tolist())
                _str_slices.append(':'+str(i*n)+' ')
            elif i == n_procs:
                # does a little extra work if the number of slices isnt divisible by n_procs
                slices.append(z_slices[ (i-1)*n: ].tolist())
                _str_slices.append(str((i-1)*n)+': ')
                print 'last slice',len(z_slices[ (i-1)*n: ])
            else:
                slices.append(z_slices[ (i-1)*n:i*n ].tolist())
                _str_slices.append(' %s:%s ' % ( (i-1)*n, i*n) )
        print 'the z-index array is sliced over %s processors like this: \n %s' % (  n_procs, _str_slices )
        print 'number of slices:', z_slices[-1]
        return slices

    def arguments(n_slices, n_procs):
        _tmp = []
        slices = get_z_coords_for_n_procs(n_slices, n_procs)
        for i in slices:
            _tmp.append([i, shape])
        return _tmp

    n_slice = 200

    if not compare_by_number_of_processors:
        _results = []
        P = processing.Pool( n_procs )
        _results = P.map(vectorized_slicer, arguments(n_slice, n_procs))

    else:
        arr = [[i, shape] for i in numpy.arange( z_min, z_max, z_delta/n_slice ).tolist()]
        for i in range(1,9):
            tA = time.time()
            _results = []
            if i == 1:
                _results = vectorized_slicer([numpy.arange( z_min, z_max, z_delta/n_slice ).tolist(), shape])
            else:
                P = processing.Pool( n_procs )
                _results = P.map(vectorized_slicer, arguments(n_slice, i))
            
            print 'slicing took %s seconds for %s processors ' % ( time.time()-tA, i)
        sys.exit()
    
    print '\n\n\n DONE SLICING ON %i CORES \n\n\n'%nprocs
    time.sleep(3)
    
    # Display result
    display, start_display, add_menu, add_function_to_menu = init_display()
    print 'displaying original shape'
    display.DisplayShape(shape)
    for n, result_shp in enumerate(_results):
        print 'displaying results from process {0}'.format(n)
        display.DisplayShape(result_shp, update=True)
    
    # update viewer when all is added:
    display.Repaint()
    total_time = time.time() - init_time
    print "%s necessary to perform slice with %s processor(s)." % ( total_time, n_procs )
    start_display()
Esempio n. 5
0
 def use_bounding_box(self):
     bbox = get_boundingbox(self._shape, EPSILON)
     xmin,ymin,zmin, xmax,ymax,zmax = bbox.Get()
     dx,dy,dz = xmax-xmin, ymax-ymin, zmax-zmin
     self._collision_geometry = ode.GeomBox(self._space, lengths=(dx,dy,dz))
     self._collision_geometry.setBody(self)
Esempio n. 6
0
def run(n_procs, compare_by_number_of_processors=False):

    shape = get_brep()
    x_min, y_min, z_min, x_max, y_max, z_max = get_boundingbox(shape)
    z_delta = abs(z_min - z_max)

    # compute bounding box!
    init_time = time.time()  # for total time computation

    def get_z_coords_for_n_procs(n_slices, n_procs):
        z_slices = numpy.arange(z_min, z_max, z_delta / n_slices)

        slices = []
        n = z_slices.shape[0] / n_procs

        _str_slices = []
        for i in range(1, n_procs + 1):
            if i == 1:
                slices.append(z_slices[:i * n].tolist())
                _str_slices.append(':' + str(i * n) + ' ')
            elif i == n_procs:
                # does a little extra work if the number of slices isnt divisible by n_procs
                slices.append(z_slices[(i - 1) * n:].tolist())
                _str_slices.append(str((i - 1) * n) + ': ')
                print 'last slice', len(z_slices[(i - 1) * n:])
            else:
                slices.append(z_slices[(i - 1) * n:i * n].tolist())
                _str_slices.append(' %s:%s ' % ((i - 1) * n, i * n))
        print 'the z-index array is sliced over %s processors like this: \n %s' % (
            n_procs, _str_slices)
        print 'number of slices:', z_slices[-1]
        return slices

    def arguments(n_slices, n_procs):
        _tmp = []
        slices = get_z_coords_for_n_procs(n_slices, n_procs)
        for i in slices:
            _tmp.append([i, shape])
        return _tmp

    n_slice = 200

    if not compare_by_number_of_processors:
        _results = []
        P = processing.Pool(n_procs)
        _results = P.map(vectorized_slicer, arguments(n_slice, n_procs))

    else:
        arr = [[i, shape]
               for i in numpy.arange(z_min, z_max, z_delta / n_slice).tolist()]
        for i in range(1, 9):
            tA = time.time()
            _results = []
            if i == 1:
                _results = vectorized_slicer([
                    numpy.arange(z_min, z_max, z_delta / n_slice).tolist(),
                    shape
                ])
            else:
                P = processing.Pool(n_procs)
                _results = P.map(vectorized_slicer, arguments(n_slice, i))

            print 'slicing took %s seconds for %s processors ' % (time.time() -
                                                                  tA, i)
        sys.exit()

    print '\n\n\n DONE SLICING ON %i CORES \n\n\n' % nprocs
    time.sleep(3)

    # Display result
    display, start_display, add_menu, add_function_to_menu = init_display()
    print 'displaying original shape'
    display.DisplayShape(shape)
    for n, result_shp in enumerate(_results):
        print 'displaying results from process {0}'.format(n)
        display.DisplayShape(result_shp, update=True)

    # update viewer when all is added:
    display.Repaint()
    total_time = time.time() - init_time
    print "%s necessary to perform slice with %s processor(s)." % (total_time,
                                                                   n_procs)
    start_display()