Replaces a row of pixels on this canvas.
 @param [Integer] y The 0-based row index.
 @param [Array<Integer>] vector The vector of pixels to replace the row
   with.
 @return [void]
963121
def replace_row!(y, vector)
      assert_y!(y) && assert_width!(vector.length)
      pixels[y * width, width] = vector
    end
84175
public void copyArea(Image target, int x, int y) {
		int format = target.getTexture().hasAlpha() ? SGL.GL_RGBA : SGL.GL_RGB;
		target.bind();
		GL.glCopyTexImage2D(SGL.GL_TEXTURE_2D, 0, format, x, screenHeight
				- (y + target.getHeight()), target.getTexture()
				.getTextureWidth(), target.getTexture().getTextureHeight(), 0);
		target.ensureInverted();
	}
135359
def move_to(self, x, y):
        
        self._drawing_operations.append(_MoveTo.new(self, x, y))
        return self
814126
def set_pixel(self,x,y,state):
	
	self.send_cmd("P"+str(x+1)+","+str(y+1)+","+state)
120972
function applyToPixel(pixel, effect, result) {
  vec4TransformMat4Transposed(result, pixel, effect.colorMatrix);
  vec4.add(result, result, effect.colorOffset);
}
382638
@SuppressWarnings("unchecked")
  public void replaceInplace(final LNGVector<? extends T> other) {
    if (this == other)
      throw new IllegalArgumentException("cannot replace a vector in-place with itself");
    this.elements = (T[]) new Object[other.size()];
    for (int i = 0; i < other.size(); i++)
      this.elements[i] = other.get(i);
    this.size = other.size;
  }
1090579
public void paintFrame (Graphics2D g, int index, int x, int y) {
        _images[index].paint(g, x, y);
    }
1004096
def displace(x,y,z)
      Geometry.new(atoms(:all).collect{|a|
        a.displace(x,y,z)
      }, self.lattice_vectors)
      #TODO copy miller indices
    end
1177024
function(x, y) {
        var renderer = this.renderer;

        var ratio = this.downSampleRatio;
        x = Math.ceil(ratio * x);
        y = Math.ceil(ratio * (this.height - y));

        this._frameBuffer.bind(renderer);
        var pixel = new Uint8Array(4);
        var _gl = renderer.gl;
        // TODO out of bounds ?
        // preserveDrawingBuffer ?
        _gl.readPixels(x, y, 1, 1, _gl.RGBA, _gl.UNSIGNED_BYTE, pixel);
        this._frameBuffer.unbind(renderer);
        // Skip interpolated pixel because of anti alias
        if (pixel[3] === 255) {
            var id = unpackID(pixel[0], pixel[1], pixel[2]);
            if (id) {
                var el = this._lookupTable[id - this.lookupOffset];
                return el;
            }
        }
    }
1194901
private int[] set2vector(HashSet<Integer> Y, int L) {
        int y[] = new int[L];
        for (int j : Y) {
            y[j] = 1;
        }
        return y;
    }
1241416
public void setVec2(String key, float x, float y)
    {
        checkKeyIsUniform(key);
        NativeShaderData.setVec2(getNative(), key, x, y);
    }
295057
def each_pixel
      get_pixels(0, 0, columns, rows).each_with_index do |p, n|
        yield(p, n % columns, n / columns)
      end
      self
    end
892455
public void setPixelValue(WritableRaster raster, int x, int y,
			short pixelValue) {
		short data[] = new short[] { pixelValue };
		raster.setDataElements(x, y, data);
	}
781250
public void set(boolean index, double x, double y) {
        this.MODE = LINES;
        if (index == true) {
            this.x1 = x;
            this.y1 = y;
        } else {
            this.x2 = x;
            this.y2 = y;
        }

        calcG();
        dx[0] = x1 - this.x;
        dx[1] = x2 - this.x;
        dy[0] = y1 - this.y;
        dy[1] = y2 - this.y;
        dz[0] = z1 - 0;
        dz[1] = z2 - 0;
        if (dashed) calcDashedLine();
    }
371144
public void updateRow(int i, VectorFunction function) {
        VectorIterator it = iteratorOfRow(i);

        while (it.hasNext()) {
            double x = it.next();
            int j = it.index();
            it.set(function.evaluate(j, x));
        }
    }
1245332
public static double[] yVals(double[] vector) {
        double[] y = new double[vector.length / 2];
        int count = 0;
        for (int i = 0; i < vector.length; i++) {
            if (i % 2 == 0)
                y[count++] = vector[i];
        }
        return y;
    }
890080
function(x, y) {
        if ( (x == null) || (y == null) ) {
            throw new TypeError('Pixel.add cannot receive null values');
        }
        return new OpenLayers.Pixel(this.x + x, this.y + y);
    }