Set the 3D geometry of the cell.
424330
def defineGeometry(self):
        """"""
        self.soma.L = 18.8
        self.soma.diam = 18.8
        self.soma.Ra = 123.0

        self.dend.L = 200.0
        self.dend.diam = 1.0
        self.dend.Ra = 100.0
413731
public void setFundamental( DMatrixRMaj F , Point3D_F64 e2 ) {
		if( e2 != null )
			this.e2.set(e2);
		else {
			MultiViewOps.extractEpipoles(F,new Point3D_F64(),this.e2);
		}
		GeometryMath_F64.multCrossA(this.e2,F,A);
	}
1202845
def bind(cell1, cell2, moduleDimensions):
  
  cell1Coords = np.unravel_index(cell1, moduleDimensions)
  cell2Coords = np.unravel_index(cell2, moduleDimensions)
  transformCoords = [(c2 - c1) % m
                     for c1, c2, m in itertools.izip(cell1Coords, cell2Coords,
                                                     moduleDimensions)]
  return np.ravel_multi_index(transformCoords, moduleDimensions)
1316494
public void setDepthsFrom3D(int view , List<Point3D_F64> locations ) {
		if( locations.size() != pixels.numCols )
			throw new IllegalArgumentException("Pixel count must be constant and match "+pixels.numCols);

		int N = depths.numCols;
		for (int i = 0; i < N; i++) {
			depths.set(view,i, locations.get(i).z );
		}
	}
274765
public void set(Vector3D v1, Vector3D v2, Vector3D v3) {
        this.MODE = TRIANGLE_3D;
        this.x1 = v1.getX();
        this.y1 = v1.getY();
        this.z1 = v1.getZ();
        this.x2 = v2.getX();
        this.y2 = v2.getY();
        this.z1 = v2.getZ();
        this.x3 = v3.getX();
        this.y3 = v3.getY();
        this.z1 = v3.getZ();
        calcG();
    }
1313056
public Cell<C,T> prefSize (float size) {
		prefWidth = new FixedValue<C, T>(layout.toolkit,size);
		prefHeight = new FixedValue<C, T>(layout.toolkit,size);
		return this;
	}
1056596
def setShape(self, shape):
        
        for pp in shape:
            if len(pp) != 3:
                raise ValueError('shape point must consist of x,y,z')
        self._shape3D = shape
        self._shape = [(x, y) for x, y, z in shape]
1057194
def _rotate_cell(self, angle, rect, back=False):
        """"""

        if angle == 90 and not back:
            self.context.rotate(-math.pi / 2.0)
            self.context.translate(-rect[2] + 4, 0)

        elif angle == 90 and back:
            self.context.translate(rect[2] - 4, 0)
            self.context.rotate(math.pi / 2.0)

        elif angle == -90 and not back:
            self.context.rotate(math.pi / 2.0)
            self.context.translate(0, -rect[3] + 2)

        elif angle == -90 and back:
            self.context.translate(0, rect[3] - 2)
            self.context.rotate(-math.pi / 2.0)

        elif angle == 180 and not back:
            self.context.rotate(math.pi)
            self.context.translate(-rect[2] + 4, -rect[3] + 2)

        elif angle == 180 and back:
            self.context.translate(rect[2] - 4, rect[3] - 2)
            self.context.rotate(-math.pi)
897500
def _set_shape(self, shape):
        

        # Delete each cell that is beyond new borders

        old_shape = self.shape
        deleted_cells = {}

        if any(new_axis < old_axis
               for new_axis, old_axis in zip(shape, old_shape)):
            for key in self.dict_grid.keys():
                if any(key_ele >= new_axis
                       for key_ele, new_axis in zip(key, shape)):
                    deleted_cells[key] = self.pop(key)

        # Set dict_grid shape attribute
        self.dict_grid.shape = shape

        self._adjust_rowcol(0, 0, 0)
        self._adjust_cell_attributes(0, 0, 0)

        # Undo actions

        yield "_set_shape"

        self.shape = old_shape

        for key in deleted_cells:
            self[key] = deleted_cells[key]
1274436
function getNormalizedPrimitive3D ({ positions, cells, normals, uvs }, opt = {}) {
    return {
      positions,
      uvs,
      normals,
      cells
    };
  }
604244
def set(self, r, g, b, intensity=None):
        """"""
        self.r = r
        self.g = g
        self.b = b
        if intensity:
            self.intensity = intensity
824009
function(){
		var pos = this.getpos(0);
		if(this.prevPos.equals(pos)){ return;}

		var cell = this.prevPos.getc();
		if(!cell.isnull){
			if(cell.qnum!==-1){
				var dir = this.prevPos.getdir(pos,2);
				if(dir!==cell.NDIR){
					cell.setQdir(cell.qdir!==dir?dir:0);
					cell.draw();
				}
			}
		}
		this.prevPos = pos;
	}
1372988
def set_window_geometry(geometry):
    

    if geometry is not None:
        x_geom, y_geom, dx_geom, dy_geom = geometry
        mngr = plt.get_current_fig_manager()
        if 'window' in dir(mngr):
            try:
                mngr.window.setGeometry(x_geom, y_geom, dx_geom, dy_geom)
            except AttributeError:
                pass
            else:
                pass
685406
def on_resize(width, height):
	""""""
	glViewport(0, 0, width, height)
	glMatrixMode(GL_PROJECTION)
	glLoadIdentity()
	gluPerspective(30, 1.0*width/height, 0.1, 1000.0)
	glMatrixMode(GL_MODELVIEW)
	glLoadIdentity()
240897
def set_geometry(self, im, geometry, options=None):
        
        if not geometry:
            return im
        options = options or {}

        width, height = geometry
        if not width and not height:
            return im

        imw, imh = self.get_size(im)
        # Geometry match the current size?
        if (width is None) or (imw == width):
            if (height is None) or (imh == height):
                return im

        ratio = float(imw) / imh

        if width and height:
            # Smaller than the target?
            smaller = (imw <= width) and (imh <= height)
            if smaller and not options['upscale']:
                return im

            resize = options.get('resize', 'fill')
            if resize == 'fill':
                new_width = width
                new_height = int(ceil(width / ratio))
                if new_height < height:
                    new_height = height
                    new_width = int(ceil(height * ratio))
            elif resize == 'fit':
                new_width = int(ceil(height * ratio))
                new_height = height
                if new_width > width:
                    new_width = width
                    new_height = int(ceil(width / ratio))
            elif resize == 'stretch':
                new_width = width
                new_height = height

        elif height:
            # Smaller than the target?
            smaller = imh <= height
            if smaller and not options['upscale']:
                return im

            new_width = int(ceil(height * ratio))
            new_height = height

        else:
            # Smaller than the target?
            smaller = imw <= width
            if smaller and not options['upscale']:
                return im

            new_width = width
            new_height = int(ceil(width / ratio))

        im = self.scale(im, new_width, new_height)
        return im
998283
public Cell<C,T> prefSize (float width, float height) {
		prefWidth = new FixedValue<C, T>(layout.toolkit,width);
		prefHeight = new FixedValue<C, T>(layout.toolkit,height);
		return this;
	}
1118638
function () {
    var data = this.data;
    var object3D = this.el.object3D;
    object3D.rotation.set(degToRad(data.x), degToRad(data.y), degToRad(data.z));
    object3D.rotation.order = 'YXZ';
  }