bicubic

I'm trying to write a basic bicubic resize algorithm to resize a 24-bit RGB bitmap. I have a general understanding of the math involved, and I'm using this implementation from Google Code as a guide. I'm not using any external libraries here - I'm just experimenting with the algorithm itself. The bitmap is represented as a plain std::vector<unsigned char> : inline unsigned char getpixel(const std::vector<unsigned char>& in, std::size_t src_width, std::size_t src_height, unsigned x, unsigned y, int channel) { if (x < src_width && y < src_height) return in[(x * 3 * src_width) + (3 * y) + channel

Below is a cubic interpolation function: public float Smooth(float start, float end, float amount) { // Clamp to 0-1; amount = (amount > 1f) ? 1f : amount; amount = (amount < 0f) ? 0f : amount; // Cubicly adjust the amount value. amount = (amount * amount) * (3f - (2f * amount)); return (start + ((end - start) * amount)); } This function will cubically interpolate between the start and end value given an amount between 0.0f - 1.0f. If you were to plot this curve, you'd end up with something like this: Expired Imageshack image removed The cubic function here is: amount = (amount * amount) * (3f

I want to draw a bitmap on a canvas with bigger size than it is. I can use canvas.drawBitmap(bitmap, null, destRect, null); but that gives a poor quality, as the result is pixelated, if the source image is sightly smaller than the destination rectangle. How can i draw my bitmap using bilinear or bicubic resampling? Any help would be appreciated, thanx. You need to set the FILTER_BITMAP_FLAG flag in your paint. canvas.drawBitmap(bitmap, matrix, null); //ugly jaggies unless scale is 1:1, but fast or Paint paint = new Paint(); paint.setFilterBitmap(); canvas.drawBitmap(bitmap, matrix, paint); //

I'm wondering if anyone has complete, working, and efficient code to do bicubic texture filtering in glsl. There is this: http://www.codeproject.com/Articles/236394/Bi-Cubic-and-Bi-Linear-Interpolation-with-GLSL or https://github.com/visionworkbench/visionworkbench/blob/master/src/vw/GPU/Shaders/Interp/interpolation-bicubic.glsl but both do 16 texture reads where only 4 are necessary: https://groups.google.com/forum/#!topic/comp.graphics.api.opengl/kqrujgJfTxo However the method above uses a missing "cubic()" function that I don't know what it is supposed to do, and also takes an unexplained

I am trying to make a pixel art themed game in HTML5 canvas, and as part of that I take 10x20 or so sized images and draw them onto the canvas with the following code: ctx.drawImage(image, 20, 20, 100, 200); However the canvas uses bicubic image scaling and hence the pixel art images look terrible at 2x and up. Is there a way to force canvas to use nearest neighbor scaling or possibly use a custom method to scale images? If not does that mean the images have to be scaled beforehand in something like Paint.net? Choose any one of the following: Via JavaScript: ctx.imageSmoothingEnabled = false;

Is there any way or external library that can resize image using Lanczos (ideally) or at least bicubic alg. under Android ? ( faster is better of course, but quality is priority, a processing time is secondary) Everything what I've got so far is this: Bitmap resized = Bitmap.createScaledBitmap(yourBitmap, newWidth, newHeight, true); However it uses bilinear filter and the output quality is terrible. Especially if you want to preserve details (like thin lines or readable texts). There are many good libraries for Java as discussed for example here: Java - resize image without losing quality