C++博客-misschuer-随笔分类-as

alchemy c 图像的缩放 (三次卷积)

此最相思 — Fri, 10 Aug 2012 02:11:00 GMT

在alchemy c中进行图片的缩放
传进的是byteArray 传出的也是byteArray 千万不要在alchemy c 中对as的对象进行函数调用那样速度很慢.... 达不到炼金术的效果...
好吧代码自己看吧还是比较简单的
alchemy c 代码
#include
#include
#include
#include <string.h>
#include
#include "AS3.h"
typedef unsigned int uint;
#define MAXV 4
using namespace std;

double SinXDivX(double x) {
    double a = -1;
    if (x < 0)
        x = -x;
    double x2 = x * x;
    double x3 = x2 * x;
    if (x <= 1)
        return (a + 2) * x3 - (a + 3) * x2 + 1;
    else if (x <= 2)
        return a * x3 - 5 * a * x2 + 8 * a * x - 4 * a;
    return 0;
}

uint availablePixel(uint *src, int srcWidth, int srcHeight, int x, int y) {
    bool flag = true;
    if (x < 0) {
        x = 0;
        flag = false;
    } else if (x >= srcWidth) {
        x = srcWidth - 1;
        flag = false;
    }
    if (y < 0) {
        y = 0;
        flag = false;
    } else if (y >= srcHeight) {
        y = srcHeight - 1;
        flag = false;
    }
    int lenth = srcWidth * srcHeight;
    int in = x + y*srcWidth;
    uint ret = src[in];
    if (!flag)
        ret = ret & 0x00ffffff;
    return ret;
}

uint border_color(double Color) {
    if (Color <= 0)
        return uint(0);
    if (Color >= 255)
        return uint(255);
    return uint(Color);
}

char *strreverse(char *a) {
    char r[10] = { 0 };
    int i, j;
    for (i = 0, j = strlen(a) - 1; a[i]; ++i, --j) {
        r[j] = a[i];
    }
    return r;
}

char *toString(uint val) {
    char a[10] = { 0 };
    char ch[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
            'C', 'D', 'E', 'F' };
    int i = 0, rt;
    if (val == 0)
        a[0] = '0';
    while (val) {
        rt = val % 16;
        val >>= 4;
        a[i++] = ch[rt];
    }
    return strreverse(a);
}

uint MatrixMutiple(double a[], uint b[][MAXV], double c[], int ii, int jj) {
    int i, j, k, z;
    double tp[MAXV], ret[MAXV], ttp[MAXV];
    memset(ret, 0.0, sizeof(ret));

    for (i = 0; i < MAXV; ++i) {
        memset(tp, 0.0, sizeof(tp));
        for (j = 0; j < MAXV; ++j) {
            tp[0] += a[j] * (b[j][i] >> 24);
            tp[1] += a[j] * ((b[j][i] & 0x00ffffff) >> 16);
            tp[2] += a[j] * ((b[j][i] & 0x0000ffff) >> 8);
            tp[3] += a[j] * (b[j][i] & 0x000000ff);
        }
        for (k = 0; k < MAXV; ++k) {
            ret[k] += c[i] * tp[k];
        }
    }

    uint af1 = border_color(ret[0] + 0.5) << 24;
    uint r1 = border_color(ret[1] + 0.5) << 16;
    uint g1 = border_color(ret[2] + 0.5) << 8;
    uint b1 = border_color(ret[3] + 0.5);

    return af1 + r1 + g1 + b1;
}

void echo(uint *val, int len) {
    int i = 0;
    for (i = 0; i < len; ++i) {
        AS3_Trace(AS3_String(toString(val[i])));
    }
}

static AS3_Val biCubic(void* self, AS3_Val args) {
    AS3_Val srcByte, dstByte;
    int srcWidth, srcHeight, dstWidth, dstHeight;
    AS3_ArrayValue(args,
            "AS3ValType, IntType, IntType, AS3ValType, IntType, IntType",
            &srcByte, &srcWidth, &srcHeight, &dstByte, &dstWidth, &dstHeight);

    int srcLen = srcWidth * srcHeight;
    int dstLen = dstWidth * dstHeight;
    uint *src = new uint[srcLen];
    uint *dst = new uint[dstLen];

    AS3_SetS(srcByte, "position", AS3_Int(0));
    AS3_ByteArray_readBytes(src, srcByte, 4 * srcLen);
    double widthFactor = 1.0 * srcWidth / dstWidth;
    double heightFactor = 1.0 * srcHeight / dstHeight;

    int i, j, k, z, gf = 0;
    double tx, ty, u, v;
    int x, y;
    double A[MAXV], C[MAXV];
    uint B[MAXV][MAXV];
    for (i = 0; i < dstWidth; ++i) {
        for (j = 0; j < dstHeight; ++j) {
            tx = (i + 0.5) * widthFactor - 0.5;
            ty = (j + 0.5) * heightFactor - 0.5;
            if (tx < 0)
                tx = -tx;
            if (ty < 0)
                ty = -ty;
            x = floor(tx);
            y = floor(ty);
            u = tx - x;
            v = ty - y;
            for (k = 0; k < MAXV; ++k) {
                A[k] = SinXDivX(u + 1.0 - k);
                C[k] = SinXDivX(v + 1.0 - k);
                for (z = 0; z < MAXV; ++z) {
                    B[k][z] = availablePixel(src, srcWidth, srcHeight,
                            x + k - 1, y + z - 1);
                }
            }
            dst[i+j*dstWidth] = MatrixMutiple(A, B, C, i, j);
        }
    }
    //echo(dst, dstLen);

    AS3_SetS(dstByte, "position", AS3_Int(0));
    AS3_ByteArray_writeBytes(dstByte, dst, 4 * dstLen);
    return AS3_True();
}

int main() {
    AS3_Val biCubicMethod = AS3_Function(NULL, biCubic);
    AS3_Val lib = AS3_Object("biCubic:AS3ValType", biCubicMethod);
    AS3_Release(biCubicMethod);
    AS3_LibInit(lib);

    return 0;
}

as 代码

package {

import cmodule.ImageScaling.CLibInit;

import flash.display.Bitmap;

import flash.display.BitmapData;

import flash.display.Sprite;

import flash.display.StageScaleMode;

import flash.geom.Rectangle;

import flash.utils.ByteArray;

import flash.utils.Timer;

[SWF(width="1000", height="600", backgroundColor="#000000", frameRate="24")]

public class Main extends Sprite {

[Embed(source='f_01.png')]

public static const image:Class;

public function Main() {

this.stage.scaleMode = StageScaleMode.NO_SCALE;

var bitmapdata:BitmapData = (new image() as Bitmap).bitmapData;

var t1:Number = (new Date()).time;

var bitmap:Bitmap = new Bitmap(Main.Cubic(bitmapdata, 256, 256));

var t2:Number = (new Date()).time;

trace((t2-t1)+"ms");

this.addChild(bitmap);

}

public static function Cubic (bitmapData:BitmapData, scalingWidth:uint, scalingHeight:uint):BitmapData {

var nbd:BitmapData = new BitmapData(scalingWidth, scalingHeight, true, 0xffffffff);

var loader:cmodule.ImageScaling.CLibInit = new cmodule.ImageScaling.CLibInit();

var lib:Object = loader.init();

var byte:ByteArray = bitmapData.getPixels(new Rectangle(0, 0, bitmapData.width, bitmapData.height));

var byte2:ByteArray = nbd.getPixels(new Rectangle(0, 0, scalingWidth, scalingHeight));

lib.biCubic(byte, bitmapData.width, bitmapData.height, byte2, scalingWidth, scalingHeight);

byte2.position = 0;

nbd.setPixels(new Rectangle(0, 0, scalingWidth, scalingHeight), byte2);

return nbd;

}

此最相思 2012-08-10 10:11 发表评论

as 图片的缩放算法 (二次线性和三次卷积)

此最相思 — Tue, 07 Aug 2012 01:58:00 GMT

package {

import flash.display.BitmapData;

public class ImageScaling {

public static var PI:Number = Math.PI;

public static function getA(val:uint):uint {

return val >>> 24;

}

public static function getR(val:uint):uint {

return (val & 0x00ffffff) >>> 16;

}

public static function getG(val:uint):uint {

return (val & 0x0000ffff) >>> 8;

}

public static function getB(val:uint):uint {

return val & 0x000000ff;

}

public static function getAA(val:Array):Array {

var ret:Array = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]];

for (var i:uint = 0; i < 4; ++ i) {

for (var j:uint = 0; j < 4; ++ j) {

ret[ i ][ j ] = val[ i ][ j ] >>> 24;

}

return ret;

}

public static function getRR(val:Array):Array {

var ret:Array = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]];

for (var i:uint = 0; i < 4; ++ i) {

for (var j:uint = 0; j < 4; ++ j) {

ret[ i ][ j ] = (val[ i ][ j ] & 0x00ffffff) >>> 16;

}

return ret;

}

public static function getGG(val:Array):Array {

var ret:Array = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]];

for (var i:uint = 0; i < 4; ++ i) {

for (var j:uint = 0; j < 4; ++ j) {

ret[ i ][ j ] = (val[ i ][ j ] & 0x0000ffff) >>> 8;

}

return ret;

}

public static function getBB(val:Array):Array {

var ret:Array = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]];

for (var i:uint = 0; i < 4; ++ i) {

for (var j:uint = 0; j < 4; ++ j) {

ret[ i ][ j ] = (val[ i ][ j ] & 0x000000ff);

}

return ret;

}

public static function availablePixel (bitmapData:BitmapData, x:uint, y:uint):uint {

var flag:Boolean = true;

if (x < 0) { x = 0; flag = false; }

else if (x >= bitmapData.width) { x = bitmapData.width - 1; flag = false; }

else if (y < 0) { y = 0; flag = false; }

else if (y >= bitmapData.height) { y = bitmapData.height - 1; flag = false; }

var ret:uint = bitmapData.getPixel32(x, y);

if (!flag) ret = ret & 0x00ffffff;

return ret;

}

public static function SinXDivX(x:Number):Number {

var a:Number = -1;

if (x < 0) x = -x;

var x2:Number = x*x;

var x3:Number = x2*x;

if (x <= 1)

return (a + 2) * x3 - (a + 3) * x2 + 1;

else if (x <= 2)

return a * x3 - 5 * a * x2 + 8 * a * x - 4 * a;

return 0;

}

public static function getPixels(a:Array, b:Array, c:Array):uint {

var arfa:Array = ImageScaling.getAA(b);

var R:Array = ImageScaling.getRR(b);

var G:Array = ImageScaling.getGG(b);

var B:Array = ImageScaling.getBB(b);

var aa:uint = ImageScaling.MatrixMutiple(a, arfa, c) << 24;

var rr:uint = ImageScaling.MatrixMutiple(a, R, c) << 16;

var gg:uint = ImageScaling.MatrixMutiple(a, G, c) << 8;

var bb:uint = ImageScaling.MatrixMutiple(a, B, c);

//trace (aa + " " + rr + " " + gg + " " + bb);

return aa + rr + gg + bb;

}

public static function border_color(Color:Number):uint {

if (Color <= 0) return uint(0);

if (Color >= 255) return uint(255);

return uint(Color);

}

public static function MatrixMutiple(a:Array, b:Array, c:Array):uint {

var ret:Number = 0;

for (var i:int = 0; i < 4; ++ i) {

var tmp:Number = 0;

for (var j:int = 0; j < 4; ++ j) {

tmp += a[ j ] * b[ j ][ i ];

}

ret += c[ i ] * tmp;

}

return border_color(ret + 0.5);

}

public static function thirdConvolution (bitmapData:BitmapData, scalingWidth:uint, scalingHeight:uint):BitmapData {

var widthFactor:Number = bitmapData.width / scalingWidth;

var heightFactor:Number = bitmapData.height / scalingHeight;

var i:uint = 0, j:uint = 0;

var nbd:BitmapData = new BitmapData(scalingWidth, scalingHeight, true, 0xffffffff);

for (i = 0; i < scalingWidth; ++ i) {

for (j = 0; j < scalingHeight; ++ j) {

var tx:Number = (i + 0.5) * widthFactor - 0.5;

var ty:Number = (j + 0.5) * heightFactor - 0.5;

if (tx < 0) tx = -tx;

if (ty < 0) ty = -ty;

var x:uint = Math.floor(tx);

var y:uint = Math.floor(ty);

var u:Number = tx - x;

var v:Number = ty - y;

var A:Array = [0.0, 0.0, 0.0, 0.0];

var B:Array = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]];

var C:Array = [0.0, 0.0, 0.0, 0.0];

for (var k:int = 0; k < 4; ++ k) {

A[ k ] = ImageScaling.SinXDivX(u+1.0-k);

C[ k ] = ImageScaling.SinXDivX(v+1.0-k);

for (var z:int = 0; z < 4; ++ z) {

B[ k ][ z ] = ImageScaling.availablePixel(bitmapData, x+k-1, y+z-1);

}

var p:uint = ImageScaling.getPixels(A, B, C);

nbd.setPixel32(i, j, p);

}

return nbd;

}

public static function calculator(p:Array, c:Array):uint {

return uint(p[0]*c[0]+p[1]*c[1]+p[2]*c[2]+p[3]*c[3]);

}

public static function mixedPixel(p:Array, c:Array):uint {

var aa:Array = [0, 0, 0, 0];

var ra:Array = [0, 0, 0, 0];

var ga:Array = [0, 0, 0, 0];

var ba:Array = [0, 0, 0, 0];

for (var i:uint = 0; i < 4; ++ i) {

aa[ i ] = ImageScaling.getA(p[ i ]);

ra[ i ] = ImageScaling.getR(p[ i ]);

ga[ i ] = ImageScaling.getG(p[ i ]);

ba[ i ] = ImageScaling.getB(p[ i ]);

}

return (ImageScaling.calculator(aa, c) << 24) + (ImageScaling.calculator(ra, c) << 16) + (ImageScaling.calculator(ga, c) << 8) + ImageScaling.calculator(ba, c);

}

public static function secondLinear (bitmapData:BitmapData, scalingWidth:uint, scalingHeight:uint):BitmapData {

var widthFactor:Number = bitmapData.width / scalingWidth;

var heightFactor:Number = bitmapData.height / scalingHeight;

var i:uint = 0, j:uint = 0;

var nbd:BitmapData = new BitmapData(scalingWidth, scalingHeight, true, 0xffffffff);

for (i = 0; i < scalingWidth; ++ i) {

for (j = 0; j < scalingHeight; ++ j) {

var tx:Number = i * widthFactor - 0.5;

var ty:Number = j * heightFactor - 0.5;

if (tx < 0) tx = -tx;

if (ty < 0) ty = -ty;

var x:uint = Math.floor(tx);

var y:uint = Math.floor(ty);

var u:Number = tx - x;

var v:Number = ty - y;

var ti:uint = x;

var tj:uint = y;

var p0:uint = ImageScaling.availablePixel(bitmapData, x, y);

var p1:uint = ImageScaling.availablePixel(bitmapData, x, y+1);

var p2:uint = ImageScaling.availablePixel(bitmapData, x+1, y);

var p3:uint = ImageScaling.availablePixel(bitmapData, x+1, y+1);

var pa:Array = [p0, p1, p2, p3];

var c0:Number = (1.0-u)*(1.0-v);

var c1:Number = (1.0-u)*v;

var c2:Number = u*(1.0-v);

var c3:Number = u*v;

var ca:Array = [c0, c1, c2, c3];

nbd.setPixel32(i, j, ImageScaling.mixedPixel(pa, ca));

}

return nbd;

}

测试:

package {

import flash.display.Bitmap;

import flash.display.BitmapData;

import flash.display.Sprite;

import flash.geom.Rectangle;

import flash.system.ImageDecodingPolicy;

import flash.utils.ByteArray;

[SWF(width="1000", height="600", backgroundColor="#cacaca", frameRate="24")]

public class Main extends Sprite {

[Embed(source='dog.png')]

public static const image:Class;

public function Main() {

var bitmapdata:BitmapData = (new image() as Bitmap).bitmapData

var bitmap:Bitmap = new Bitmap(showImage2(bitmapdata));

bitmap.x = 0;

bitmap.y = 0;

this.addChild(bitmap);

var bitmap2:Bitmap = new Bitmap(showImage1(bitmapdata));

bitmap2.x = 300;

bitmap2.y = 300;

this.addChild(bitmap2);

}

public static function showImage1(bitmapdata:BitmapData):BitmapData {

return ImageScaling.secondLinear(bitmapdata, 286, 300);

}

public static function showImage2(bitmapdata:BitmapData):BitmapData {

return ImageScaling.thirdConvolution(bitmapdata, 286, 300);

}

__________________________________________________
参考h ttp://blog.csdn.net/housisong/article/details/1452249

此最相思 2012-08-07 09:58 发表评论

C++博客-misschuer-随笔分类-as

alchemy c 图像的缩放 (三次卷积)

as 图片的缩放算法 (二次线性 和 三次卷积)

as 图片的缩放算法 (二次线性和三次卷积)