resize the Image Layer to match the given size
@name resize
@memberOf me.ImageLayer.prototype
@function
@param {Number} w new width
@param {Number} h new height
972257
function resize(w, h) {
         this._super(me.Renderable, "resize", [this.repeatX ? Infinity : w, this.repeatY ? Infinity : h]);
       }
991296
function ( o, w, h, force ) {

        // prevent exesive redraw

        if( force && R.tmpTime !== null ) { clearTimeout(R.tmpTime); R.tmpTime = null;  }

        if( R.tmpTime !== null ) return;

        if( R.lock ) R.tmpTime = setTimeout( function(){ R.tmpTime = null; }, 10 );

        ///

        var isNewSize = false;
        if( w !== o.canvas.width || h !== o.canvas.height ) isNewSize = true;

        if( R.tmpImage === null ) R.tmpImage = new Image();

        var img = R.tmpImage; //new Image();

        var htmlString = R.xmlserializer.serializeToString( o.content );
        
        var svg = '<svg xmlns="http://www.w3.org/2000/svg" width="'+w+'" height="'+h+'"><foreignObject style="pointer-events: none; left:0;" width="100%" height="100%">'+ htmlString +'</foreignObject></svg>';

        img.onload = function() {

            var ctx = o.canvas.getContext("2d");

            if( isNewSize ){ 
                o.canvas.width = w;
                o.canvas.height = h;
            }else{
                ctx.clearRect( 0, 0, w, h );
            }
            ctx.drawImage( this, 0, 0 );

            o.onDraw();

        };

        img.src = "data:image/svg+xml;charset=utf-8," + encodeURIComponent(svg);
        //img.src = 'data:image/svg+xml;base64,'+ window.btoa( svg );
        img.crossOrigin = '';


    }
482491
static function resizeIgnoringAspectRatio(\Intervention\Image\Image $img, $w, $h) {
        return $img->resize($w, $h);
    }
450754
function resize() {
    var w = $(window).width(), h = $(window).height();
    canvas.attr({ width: w, height: h });
    scene.getCamera().setAspect(w / h);
    renderer.clearViewport();
  }
556127
public ImageHandlerBuilder resize(int width, int height) {
         BufferedImage resize = Scalr.resize(image, Scalr.Mode.FIT_EXACT, width, height);
         image.flush();
         image = resize;
         return this;
     }
45984
def resize(img, width, height):
    
    return img.resize((width, height), Image.ANTIALIAS)
990353
public function resize($blocks, $newW, $newH){
        $images = $this->splitFrames($blocks);

        // Loop on individual images and resize them using Gd
        $firstFrameGd = null;
        foreach($images as $imageIndex=>$image){
            $hex = $this->encode($image);
            $binaryRaw = pack('H*', $hex);

            // Utilize gd for resizing
            $old = imagecreatefromstring($binaryRaw);
            $width  = imagesx($old);
            $height = imagesy($old);
            $new = imagecreatetruecolor($newW, $newH); // Create a blank image
            if($firstFrameGd){
                $new = $firstFrameGd;
            }
            // Account for frame imageLeft and imageTop
            $cX = $newW / $blocks['canvasWidth']; // change x
            $dX = $image['frames'][0]['imageLeft'];
            $cY = $newH / $blocks['canvasHeight'];
            $dY = $image['frames'][0]['imageTop'];

            imagecopyresampled(
                $new,
                $old,
                $dX * $cX,// dx
                $dY * $cY, // dy
                0,
                0,
                $image['frames'][0]['imageWidth'] * $cX,
                $image['frames'][0]['imageHeight'] * $cY,
                $width,
                $height
            );
            ob_start();
            imagegif($new);
            $binaryRaw = ob_get_contents();
            ob_end_clean();

            if($firstFrameGd===null){
                $firstFrameGd = $new;
            }

            // Hex of resized
            $bytes = $this->load($binaryRaw);
            $hexNew = $this->decode($bytes);



            // Update original frames with hex from resized frames
            $blocks['frames'][$imageIndex]['imageWidth'] = $hexNew['frames'][0]['imageWidth'];
            $blocks['frames'][$imageIndex]['imageHeight'] = $hexNew['frames'][0]['imageHeight'];
            $blocks['frames'][$imageIndex]['imageLeft'] = $hexNew['frames'][0]['imageLeft'];
            $blocks['frames'][$imageIndex]['imageTop'] = $hexNew['frames'][0]['imageTop'];
            $blocks['frames'][$imageIndex]['imageData'] = $hexNew['frames'][0]['imageData'];

            // We use local color tables on each frame. This will result in faster processing since we dont have to process the global color table at the cost of a larger file size.
            $blocks['frames'][$imageIndex]['localColorTableFlag'] = $hexNew['globalColorTableFlag'];
            $blocks['frames'][$imageIndex]['localColorTable'] = $hexNew['globalColorTable'];
            $blocks['frames'][$imageIndex]['sizeOfLocalColorTable'] = $hexNew['sizeOfGlobalColorTable'];
            $blocks['frames'][$imageIndex]['transparentColorFlag'] = 0;
        }
        // Update dimensions or else imagecreatefromgif will choke.
        $blocks['canvasWidth'] = $newW;
        $blocks['canvasHeight'] = $newH;
        // Disable flickering bug. Also we are using localColorTable anyways.
        $blocks['globalColorTableFlag'] = 0;
        $blocks['globalColorTable'] = '';
        return $blocks;
    }
669753
function (width, height) {
        this._lightAccumTex.width = width;
        this._lightAccumTex.height = height;

        // PENDING viewport ?
        this._gBuffer.resize(width, height);
    }
792667
@Override protected void onSizeChanged(int w, int h, int oldw, int oldh) {
    super.onSizeChanged(w, h, oldw, oldh);

    setupBounds(w, h);
    setupPaints();
    invalidate();
  }
280759
def resize(self, width, height):
        ''
        self.canvas.SetInitialSize(wx.Size(width, height))
        self.window.GetSizer().Fit(self.window)
529164
private void updateErrorContainerSize(double w, double errorContainerHeight) {
        errorContainerClip.setWidth(w);
        errorContainerClip.setHeight(errorContainerHeight);
        resize(w, errorContainerHeight);
    }
947086
def resize(self, width, height):
        
        self._width = width
        self._height = height
        if width != "fill":
            self._set_tk_config("width", width)
        if height != "fill":
            self._set_tk_config("height", height)
        if width == "fill" or height == "fill":
            self.master.display_widgets()
757748
function (width, height, interpolation) {
		this.widthOriginal = parseInt(this.width);
		this.heightOriginal = parseInt(this.height);
		this.targetWidth = Math.abs(parseInt(width) || 0);
		this.targetHeight = Math.abs(parseInt(height) || 0);
		this.colorChannels = 4;
		this.interpolationPass = !!interpolation;

		this.targetWidthMultipliedByChannels = this.targetWidth * this.colorChannels;
		this.originalWidthMultipliedByChannels = this.widthOriginal * this.colorChannels;
		this.originalHeightMultipliedByChannels = this.heightOriginal * this.colorChannels;
		this.widthPassResultSize = this.targetWidthMultipliedByChannels * this.heightOriginal;
		this.finalResultSize = this.targetWidthMultipliedByChannels * this.targetHeight;
		
		
		if (this.widthOriginal == this.targetWidth) { //Bypass the width resizer pass:
			this.resizeWidth = this._bypassResizer;
		}
		else { //Setup the width resizer pass:
			this.ratioWeightWidthPass = this.widthOriginal / this.targetWidth;
			if (this.ratioWeightWidthPass < 1 && this.interpolationPass) {
				this._initializeFirstPassBuffers(true);
				this.resizeWidth = this._resizeWidthInterpolatedRGBA;
			}
			else {
				this._initializeFirstPassBuffers(false);
				this.resizeWidth = this._resizeWidthRGBA;
			}
		}
		if (this.heightOriginal == this.targetHeight) { //Bypass the height resizer pass:
			this.resizeHeight = this._bypassResizer;
		}
		else {	
			//Setup the height resizer pass:
			this.ratioWeightHeightPass = this.heightOriginal / this.targetHeight;
			if (this.ratioWeightHeightPass < 1 && this.interpolationPass) {
				this._initializeSecondPassBuffers(true);
				this.resizeHeight = this._resizeHeightInterpolated;
			}
			else {
				this._initializeSecondPassBuffers(false);
				this.resizeHeight = this._resizeHeightRGBA;
			}
		}
		
		this.data = this.resizeHeight(this.resizeWidth(this.data));
		
		this.width = width;
		this.height = height;
	}
89382
function resizeImage(options, callback) {
  var size = options.size.width + 'x' + options.size.height;
  if (!options.size.maintainratio) {
    size += '\\!';
  }
  var command = [
    options.convert,
    options.org,
    '-adaptive-resize',
    options.size.width + 'x' + options.size.height,
    options.path
    ].join(' ');

  /* Create folder if we have to. */
  var dest = lib.path.join(options.dest, options.size.name);
  if (!lib.fs.existsSync(dest)) {
    lib.fs.mkdirSync(dest);
  }

  /* Create resize */
  lib.exec(command, function (err, stdout, stderr) {
    callback(err, options.path);
  });
}
1115560
def resize(self, height, width, **kwargs):
        
        self.client.exec_resize(self.exec_id, height=height, width=width)
384950
public void resize(int w, int h) {

        // using the new approach of Java 2D API
        BufferedImage buf = new BufferedImage(w, h, image.getType());
        Graphics2D g2d = (Graphics2D) buf.getGraphics();
        g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
        g2d.drawImage(image, 0, 0, w, h, null);
        g2d.dispose();
        image = buf;
        width = w;
        height = h;
        updateColorArray();
    }
81404
function( width, height ) {
		if( width !== this.width || height !== this.height ) {
			this.width = width;
			this.height = height;
			this._contentElement.outerWidth( width )
			     .outerHeight( height );
			this.emit( 'resize' );
		}
	}