update the polygons when the model changes
499226
function updatePolys() {
        border.geometry([0,200,
            adsr.a(),50,
            adsr.d(),adsr.s(),
            adsr.r(),adsr.s(),
            300,200]);
        aPoly.geometry([
            0,200,
            adsr.a(),50,
            adsr.a(),200
            ]);
        dPoly.geometry([
            adsr.a(),200,
            adsr.a(),50,
            adsr.d(),adsr.s(),
            adsr.d(),200,
            ]);
        sPoly.geometry([
            adsr.d(),200,
            adsr.d(),adsr.s(),
            adsr.r(),adsr.s(),
            adsr.r(),200,
            ])
        rPoly.geometry([
            adsr.r(),200,
            adsr.r(),adsr.s(),
            300,200
            ]);

    }
780688
def update_models(new_obj, current_table, tables, relations):
    
    _update_check_inputs(current_table, tables, relations)
    _check_no_current_table(new_obj, current_table)

    if isinstance(new_obj, Table):
        tables_names = [t.name for t in tables]
        _check_not_creating_duplicates(new_obj.name, tables_names, 'table', DuplicateTableException)
        return new_obj, tables + [new_obj], relations

    if isinstance(new_obj, Relation):
        tables_names = [t.name for t in tables]
        _check_colname_in_lst(new_obj.right_col, tables_names)
        _check_colname_in_lst(new_obj.left_col, tables_names)
        return current_table, tables, relations + [new_obj]

    if isinstance(new_obj, Column):
        columns_names = [c.name for c in current_table.columns]
        _check_not_creating_duplicates(new_obj.name, columns_names, 'column', DuplicateColumnException)
        current_table.columns.append(new_obj)
        return current_table, tables, relations

    msg = "new_obj cannot be of type {}"
    raise ValueError(msg.format(new_obj.__class__.__name__))
796481
protected void updateText() 
    {
        super.updateText();
        _exampleInfo[3].setText("[PageUp] Next model");
        _exampleInfo[4].setText("[PageDown] Previous model");
        _exampleInfo[5].setText("[1] Generate polygon type A ");
        _exampleInfo[6].setText("[2] Generate polygon type B ");
    }
863235
public void updateFromModel(FgModel model) {
        initialized = true;
        int numConfigs = this.getVars().calcNumConfigs();
        for (int c=0; c<numConfigs; c++) {
            double dot = getDotProd(c, model);                
            assert !Double.isNaN(dot) && dot != Double.POSITIVE_INFINITY : "Invalid value for factor: " + dot;
            this.setValue(c, dot);
        }
    }
16725
def update_model(self, idx=None):
        """"""
        if idx is None:
            for w in self._widgets:
                idx = self._get_idx_from_widget(w)
                try: val = self._read_widget(idx)
                except ValueError: pass
                else: self._write_property(val, idx)
                pass
            pass
        else:
            try: val = self._read_widget(idx)
            except ValueError: pass
            else: self._write_property(val, idx)
        return
208749
def update(self):
        """"""
        con = self.subpars.pars.control
        self(con.ypoints.shape[0])
382392
function() { 
                obj.mesh[ propertyName ].set( propertyObject.x, propertyObject.y, propertyObject.z )
              }
709026
function () {
        var flipX = this.flipX;
        var flipY = this.flipY;
        var bones = this.bones;
        for (var i = 0, n = bones.length; i < n; i++)
            bones[i].updateWorldTransform(flipX, flipY);
    }
619965
def update_data(ctx, models=True, pickles=False, f=False):
    
    if pickles:
        save_sql_to_files(f)
    if models:
        if f:
            manage(ctx, 'create_models_from_sql --force True', env={})
        else:
            manage(ctx, 'create_models_from_sql', env={})
1092279
public void updateFeatures() {
	for (int i = 0; i < feaGen.features.size(); i++) {
	    Feature f = (Feature)feaGen.features.get(i);
	    f.wgt = lambda[f.idx];    
	}
    }
1242861
public void updateColumnMappings() {
        columnMapping = new HashMap<>();
        int realIdx = 0;
        int renderCol = 0;
        for (final SheetColumn column : getColumns()) {
            if (column.isRendered()) {
                columnMapping.put(renderCol, realIdx);
                renderCol++;
            }
            realIdx++;
        }
    }
1334447
def update_vertices(self, mask):
        
        if self.uv is not None:
            self.uv = self.uv[mask]
818820
def update(self, **kwargs):
        """"""
        self.inflate()
        for model in self._models:
            model.update(**kwargs)
        return self
626952
def _update_object_map(self, obj_map):
        
        obj_map['droppables'] = self.get_droppables()
        obj_map['targets'] = self.get_targets()
        obj_map['zones'] = self.get_zones()
705393
function(vertex) {
        this.resetVertices();
        this.setFeatureState();
        this.onModification(this.feature);
        this.layer.events.triggerEvent("featuremodified", 
                                       {feature: this.feature});
    }
263201
def _update_mask(self, mask: np.ndarray, polygons: Iterable, separate_instances: bool = False) -> None:
        
        for i, p in enumerate(polygons):
            if isinstance(p, geometry.MultiPolygon):
                self._update_mask(mask=mask, polygons=p.geoms, separate_instances=True)
                continue
            elif not isinstance(p, geometry.Polygon):
                continue
            poly_area = Image.fromarray(np.zeros(mask.shape, dtype=np.uint8))
            holes = Image.fromarray(np.zeros(mask.shape, dtype=np.uint8))
            outline_color = 0 if separate_instances else 255
            ImageDraw.Draw(poly_area).polygon(p.exterior.coords, fill=255, outline=outline_color)
            for h in p.interiors:
                ImageDraw.Draw(holes).polygon(h.coords, fill=255, outline=255)
            mask[np.nonzero(np.array(poly_area, dtype=np.uint8))] = 255
            mask[np.nonzero(np.array(holes, dtype=np.uint8))] = 0
214794
private void updateBounds()
    {
        if (npoints >= MIN_POINTS)
        {
            double boundsMinX = Double.MAX_VALUE;
            double boundsMinY = Double.MAX_VALUE;
            double boundsMaxX = -Double.MAX_VALUE;
            double boundsMaxY = -Double.MAX_VALUE;

            for (int i = 0; i < npoints; i++)
            {
                final double x = xpoints[i];
                boundsMinX = Math.min(boundsMinX, x);
                boundsMaxX = Math.max(boundsMaxX, x);

                final double y = ypoints[i];
                boundsMinY = Math.min(boundsMinY, y);
                boundsMaxY = Math.max(boundsMaxY, y);
            }

            bounds.set(boundsMinX, boundsMinY, boundsMaxX - boundsMinX, boundsMaxY - boundsMinY);
        }
    }