久久久精品久久久久久,久久久91精品国产一区二区三区,99久久免费国产特黄

Shihira — Tue, 11 Aug 2015 16:35:00 GMT

��L��的介�l?/h1>
��L��Q�convolution�Q?/em>是泛函分析里的一个概念，不过泛函分析一般都是数学系才学的，计算机系的学生大多在概率�l�计课本里了解到。它分�ؓ两种形式�Q�一个是��L��形式�Q�一个是�q�箋�Q�积分）形式。在囑փ�处理中我们更兛_��L��L��Q�不�q�也先看看积分�Ş式的��L��。现在假设我们有两个函数�?img src="http://latex.codecogs.com/gif.latex?g%28x%29" alt="g(x)" />�Q�这�?img src="http://latex.codecogs.com/gif.latex?g%28x%29" alt="g(x)" />又叫�?strong>�q�x��函数或�?strong>��L��?/strong>�Q�那么它们在�q�箋�I�间的卷�U�是�Q?/p>
一般我们有一个这��L��l�论�Q�就是当�l�过��_��多次相同�q�x��函数��L��Q�就会��够接�q�高斯函敎ͼ�也就是正态分布的函数形式。卷�U�就是一�U��^滑操作，�q�说明高斯函数就�?#8220;最�q�x��的函�?#8221;。引入热力学中熵的概念，高斯函数��是拥有最高熵的函敎ͼ�最�E�_��的状态，以至于自然界大多数的�l�计规律都呈现出正态分布：

下面介绍��L��形式的卷�U�。这��L��Q�首先是由有限项的多��式体现。神奇的是，而它们的乘积��是��L��。首先我们设有两个多��式以及。计��它们的乘积�Q?/p>
再引入离散�Ş式卷�U�（向量��L��Q�的定义�Q�大家比较一下这个定义和上面多项式的计算。稍微说明一下，中括��L��意义�?strong>p[n]代表向量�W�n个元�?/strong>。将两个多项式的�p�L��写成向量形式然后�q�行向量��L��Q�也��是例如�Q�而没定义的地方当�?。可以发玎ͼ�两者是完全一致的�Q?/p>
知道了多��式的乘�U�就是其相应的卷�U�，我们甚至可以直接得出两个�q��数卷�U�的�l�果。因为泰勒��数就是幂�U�数的一�U�，所以我们可以将几乎所有的�q�箋函数转换成离散�Ş式，避免了繁复的�U�分�q�算�Q�比如我们希望得�?�Q�其�?img src="http://latex.codecogs.com/gif.latex?p%28x%29%20=%20%5Csum%20a_i%20x%5Ei,%5C%20%20q%28x%29%20=%20%5Csum%20b_i%20x%5Ei" alt="p(x) = \sum a_i x^i,\ q(x) = \sum b_i x^i" />�Q�只需要简单地计算�q�两个��数的柯西乘积�Q�所得结果就�?img src="http://latex.codecogs.com/gif.latex?r%28x%29" alt="r(x)" />的卷�U�。当然了�Q�这是后话，与本文的主题无关�?/p>

��L��与图像处�?/h1>
在开始讲囑փ�处理之前�Q�我希望先理解一下卷�U�的整个�q�程是怎样的。从上面的公式看得还是有�Ҏ��應|��懂，从直觉上�ȝ��解一下很有必要。观察卷�U�的公式以及下面的图片，�q�个�q�程可以看作�Q�当你想求一个r[n]的时候：

你先把卷�U�核q叠在p上面�Q?strong>��量使左端靠�q�（如果左对齐就再好不过了）�Q�然后看看在[0, n]�?/strong>p, q重叠的部分是从哪里到哪里�Q�分别写成向量，那么r[n]��q��于其中一个向量与另一个向量的逆序的内�U��?/p>

比如当n = 2�Ӟ��两个向量�?code>[a_0, a_1, a_2]�?code>[b_2, b_1, b_0]�Q�n = 4�Ӟ��两个向量�?code>[a_1, a_2, a_3, a_4]�?code>[b_3, b_2, b_1, b_0]。至于求内积�Q�一定难不倒你。下图说明了�q�一点：

上面是对某一点上��L��的理解。对整个域的��L��Q�则可以看成是将��L��核（除了开头几个外�Q�不停向右移动，每移动一格就��重叠部分拿出来求内�U��?/p>
�q�时我们可以把图像处理和��L��联系��h��了。图像处理是�Q�将一�?#8220;源图�?#8221;�Q�Source�Q?/em>�Q�通过一些算法，变成一�?#8220;目标囑փ�”�Q�Destination�Q?/em>。当我们�q�行�q�x��处理的时候，用到一个叫做��o波器�Q�filter�Q?/em>�?东西�Q�也叫做滤镜。想��x��们现实生�z�M��攑֤�镜是怎么用的�Q�拿着攑֤�镜，从报�U�的左上角开始，一直扫啊扫到右下角�Q�扫的过�E�中一直望着攑֤�镜和报纸的重叠区域（其实��是望着攑֤�镜，因�ؓ它比报纸��多了）�Q�这样你��浏览完了一张放大过的报�U�。��^滑��o镜也是同��L��使用�Ҏ��Q�从源图的左上角开始扫到右下角�Q�扫的过 �E�中一直取出重叠部分进�?strong>内积计算�Q�然后将�l�果存放到目标图像中 —— 昄��q�个操作跟卷�U�是一致的�Q�只不过定义在二�l�空间内�?/p>
��Z��方便量化表示�Q�我们把囑փ�抽象成定义在数环内的二维矩阵�Q�其意义�?strong>灰度�?/strong>�Q�颜色信息我们暂且忽略。卷�U�核�Q�也��是滤�L器同样也是定义在内的二维矩阵。这��P��二维的卷�U�我们这样定义它的离散�Ş式：

我们的卷�U�核大小�q�不是无限的�Q�它一个半径r�Q�这样它的大��就�?r+1。规定了�q�个r使得�Q�当|x| > r �?|y| > r�Q�都有Ker[y, x] = 0。规定过大小之后�Q�由 `|i-y| < r; |j-x| < r`得到 `i-r < y < i+r; j-r < x < j+r`。同时我们规定Dest和Src的大��是。于是我们得��C��滤�L器的��法�Q?/p>
高斯滤�L�?/h1>

二维的高斯函敎ͼ�俗称避孕套函敎ͼ�

高斯滤�L器是最常用的��^滑��o波器之一�Q�在Photoshop里面它被用作高斯模糊滤镜。高斯��o波器的定义很�l�典�Q�就是简单地把正态分布离散开来。二�l��Ş式只是单�U�把x替代�?x² + y²)�Q�然后修改系��C�o实数域上的积分�ؓ1�Q?/p>
也许你已�l�发��C��一个这��L��规律�Q�这一规律�Q�这在更高维上仍然是满��的，也就是在�q�箋�I�间里同��h��뀂这��成为我们优化算法的关键。将�q�个规律代回��C��l�离散卷�U�的公式里，因�ؓy在第二个�q�加中相当于常数�p�L��可以提出来，我们发现�Q?/p>
如果x�q�加所表示是卷�U�是从右上角开始按照文字书写顺序从左到叻I��然后从上��C��的顺序进行一�l�卷�U�，那么y�q�加表示的卷�U�就是先从上��C��Q�再从左到有的顺序卷�U�。在OpenCV提供的数据结构的基础上，不用imgproc提供的算法，我写了一个示例：

1 // cflags: -lopencv_highgui -lopencv_core
2
3 #include <iostream>
4 #include <cmath>
5 #include <opencv2/highgui/highgui.hpp>
6
7 using namespace cv;
8 using namespace std;
9
10 const char* title = "gaussian-filter";
11
12 Mat kernelMatrix(int radius, double sigma)
13 {
14         int d = radius * 2 + 1;
15         Mat kernel(2, d, CV_64F);
16
17         double coef = 0;
18         for(int i = 0; i <= radius; i++) {
19                 // f(x) = 1/(sigma * sqrt(2 pi)) * e ^ -x^2/(2 s^2)
20                 int dx = i - radius;
21                 double dx_2 = dx * dx;
22                 double w = pow(M_E, - dx_2 / (2 * sigma * sigma));
23
24                 coef += w;
25                 kernel.at<double>(0, i) = w;
26                 kernel.at<double>(0, d - i - 1) = w;
27                 // when you used values from i to j (j>i), the sum of them is:
28                 // kernel[1, j] - (i ? kernel[1, i-1] : 0)
29                 kernel.at<double>(1, i) = coef;
30         }
31
32         for(int i = radius + 1; i < d; i++) {
33                 coef += kernel.at<double>(0, i);
34                 kernel.at<double>(1, i) = coef;
35         }
36
37         return kernel;
38 }
39
40
41 void convolution(const Mat& img, const Mat& kernel, Mat& output, bool t = true)
42 {
43         for(int y = 0, x = 0; y < img.rows; x = (++x<img.cols)? x : (y++, 0)) {
44                 Vec3d r(0, 0, 0);
45
46                 int ideal = x - int(kernel.cols / 2),
47                     ran_beg = max(ideal, 0) - ideal,
48                     ran_end = min(ideal + kernel.cols, img.cols) - ideal;
49
50                 for(int i = ran_beg; i < ran_end; i++) {
51                         double weight = kernel.at<double>(0, i);
52                         Vec3b pixel = img.at<Vec3b>(y, ideal + i);
53
54                         r[0] += pixel[0] * weight;
55                         r[1] += pixel[1] * weight;
56                         r[2] += pixel[2] * weight;
57                 }
58
59                 double coef = kernel.at<double>(1, ran_end - 1);
60                 if(ran_beg) coef -= kernel.at<double>(1, ran_beg - 1);
61
62                 output.at<Vec3b>(t?x:y, t?y:x) = Vec3b(
63                         saturate_cast<uchar>(r[0]/coef),
64                         saturate_cast<uchar>(r[1]/coef),
65                         saturate_cast<uchar>(r[2]/coef));
66         }
67 }
68
69
70 int main()
71 {
72         namedWindow(title, WINDOW_AUTOSIZE);
73
74         const int r = 10;
75
76         Mat img = imread("ai-sample.jpg"),
77             kernel = kernelMatrix(r, (r - 1) * 0.3 + 0.8);
78
79         Mat product_v = Mat(img.cols, img.rows, img.type());
80         Mat product_h = Mat(img.rows, img.cols, img.type());
81
82         convolution(img, kernel, product_v);
83         convolution(product_v, kernel, product_h);
84
85         imshow(title, product_h);
86         for(; waitKey(0) > 0;);
87
88         destroyWindow(title);
89 }

渲染效果�?/div>

Shihira 2015-08-12 00:35 发表评论

AGG入门�Q�八�Q?- 渲染

Shihira — Wed, 01 Aug 2012 12:01:00 GMT

一、引�a�

让我们来看一看渲染具体的��程囑֐��Q?/div>

上面提到了几个概念，再解释一下：

��点源（Vertex Source�Q�：用顶点的方式描述矢量囑�Ş�Q?/li>
光栅化（Resterizer�Q�：它的作用是把��点源所描绘的图形与像素对应��h��Q�可以说�c�M��于Photoshop上的矢量蒙版�Q?/li>
扫描�U�（Scanline�Q�：扫描�U�的作用��是为扫描线渲染器提供一个扫描的方式和区域，使渲染器有序地填充；

扫描�U�渲染器�Q�Scanline Renderer�Q�：分实色和自定义渲染器两类�Q�实色只允许你用单一的颜色去�q�行渲染�Q�而自定则可做得多姿多彩，比如渐变、位图；它相当于GDI里的��d��?/li>

二、工�?/h3>
�q�次我们以一个自制的��点源与椭圆�l�合作�ؓ渲染对象�Q�用宝蓝色的实色渲染器进行渲染；

#include

//................

class triangle_path {
public:
    triangle_path()
    {
        unsigned tmp_array[4][3]={
            {0  , 250, agg::path_cmd_move_to},
            {500, 250, agg::path_cmd_line_to},
            {250, 500, agg::path_cmd_line_to},
            {0  ,   0, agg::path_cmd_stop}
        };
        memcpy(m_points[0], tmp_array[0], sizeof(m_points));
    }
    unsigned vertex(double *x, double* y)
    {
        *x = m_points[m_step][0];
        *y = m_points[m_step][1];
        unsigned r = m_points[m_step][2];
        m_step++;
        return r;
    }
    void rewind(int)
    {
        m_step = 0;
    }
private:
    int m_step;
    unsigned m_points[4][3];
};

//...... in class the_application

    void on_draw()
   {
        ren_bas.reset_clipping(true);
        ren_bas.clear(agg::rgba8(255, 255, 255));

        agg::ellipse ellipse(250, 125, 125, 125);
        triangle_path triangle;
        rasterizer.reset();
        rasterizer.add_path(triangle);
        rasterizer.add_path(ellipse);
        agg::render_scanlines_aa_solid(rasterizer, scanline, ren_bas,
            agg::rgba8(45, 108, 155));  //注意�Q�函数名中的scanline是复敎ͼ��Q?/span>
    }

三、解�?/h3>
先看on_draw函数�Q�我们先定义了两个顶�Ҏ��Q�一个是椭圆�Q�另一个是自制的三角�Ş�Q�先把rasterizer重置�Q�清除上�ơ重�l�留下的光栅信息�Q�我们再在光栅中��d��q�两个顶�Ҏ��Q�用渲染器渲染，��是了；
你可能感到奇怪：��Z��么没有扫描线渲染器的定义呢？其实�?span style="color: #ff0000; ">render_scanlines_aa_solid里，��已�l�帮你定义好了实色渲染器。把render_scanlines_aa_solid展开成：
agg::renderer_scanline_aa_solid> renderer_scanline(ren_bas);
renderer_scanline.color(agg::rgba8(45, 108, 155, cover));
agg::render_scanlines(rasterizer, scanlines, renderer_scanline);
效率是一��L��Q�只不过函数版本更加��z��?/div>
��点源的定义�Q�结合上一节的知识和agg_basics.h中关于path_commands_e和path_flags_e的定义，应该是可以理解的�Q?/div>

Shihira 2012-08-01 20:01 发表评论

Shihira — Tue, 24 Jul 2012 08:30:00 GMT

一、修�Ҏ��?/h3>
现在�l�于�q�入了真正的矢量�l�图阶段�Q�我们的模版也需要有所改变�Q�至于�ؓ什么，有什么作用，以后会说刎ͼ�
包含下面的头文�g�Q��ƈ且在the_application�c�M��d��两个成员�?/div>

//扫描�U�和扫描�U�光栅器
#include
#include

private:
    //扫描�U�和扫描�U�光栅器
    agg::scanline_u8 scanline;
    agg::rasterizer_scanline_aa<> rasterizer;

二、顶�Ҏ��

��点源（Vertex Source�Q�不是一个类�Q�而是一�U�类的模式。这�U�类里面有rewind()函数和vertex()函数�l�AGG内部调用�Q�没错，�q�就是它的定义）。类如其名，��点源就是�ؓ�l�图�pȝ��提供��点信息的，大家能想象得��两个函数的作用了吗？

rewind()�Q�回到最开始个步骤�Q?/div>
vertex(double* x, double* y)�Q�每调用一�ơ，跳一个步骤（点）�Q�每一个步骤都输出��点的x,y坐标�Q�灰色字�Q�，以及�q�个坐标的绘囑֑�令（紫色字）�Q?br />

三、内�|�顶�Ҏ��

AGG内置了大量的��点源，我们可以直接调用�Q�他们包括：

agg::path_storage

agg::arc

agg::rounded_rect

agg::ellipse

agg::curve3

agg::curve4 ......

�{�等�Q��ؓ什么没有线、点��点源？其实�Q�path_storage已经内置了画�U�函数、画弧函数、画贝塞��曲�U�函敎ͼ�你可以用path_storage创造几乎�Q何的囑�Ş。至于画点，copy_pixel()或者用椭圆�?#8230;…

四、�\径储存器

Path storage 是用来管理�\径、画复杂囑�Ş的。在上面可以��L��d��直线、曲�Uѝ��其他�\径�?/div>
头文�?/h4>
#include

�c�d��定义

typedef path_basedouble> > path_storage;

基本成员函数

move_to()
    ��d��命��o�?path_cmd_move_to 的顶点，意�ؓ下一条线从这个点开始画�Q?/li>
line_to()
    ��d��命��o�?path_cmd_line_to 的顶点，意�ؓ�ȝ��到这个点�Q?/li>
arc_to(double rx, double ry, double angle, bool large_arc_flag, bool sweep_flag, double x, double y)
    ��d��一条弧路径�Q�画轴长为rx, ry�Q�角度�ؓangle�Q�优/劣弧�Q�顺逆时针，�l�点�?x,y)�?/li>
curve3_to()
    ��d��贝塞��曲�U�，参数��Z��个控制点和终点的坐标

curve4_to()
    ��d��贝塞��曲�U�，参数��Z��个控制点和终点的坐标

join_path()
    ��d��一个顶�Ҏ��Q�即�l�合

vertex(unsigned idx, double* x, double* y)
last_vertex(double* x, double* y)
vertex(double* x, double* y)
    取顶点位�|�，前者�ؓ已知步骤�Q�后两者�ؓ��序或倒序获取

modify_vertex()
modify_command()
    修改步骤为idx的顶点坐标和命��o

五、其他顶�Ҏ��

其他��点源就不一一介绍了，只列出其头文件和构造函敎ͼ�

#include
ellipse(double x, double y, double rx, double ry, unsigned num_steps=0, bool cw=false)
    圆心(x, y)和长短半轴分别�ؓrx, ry�Q�步骤数位num_steps�Q�无用）�Q�cw军_��怺�地方是否�I�出

#include
arc(double x, double y, double rx, double ry, double a1, double a2, bool ccw=true)
    圆心�?x, y)和长短半轴分别�ؓrx, ry�Q�初始角度和�l�结角度为a1, a2

#include
curve3(double x1, double y1, double x2, double y2, double x3, double y3)
    三个点，分别为：初始点，控制点一�Q�终�l�点

#include
curve4(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
    四个点，分别为：初始点，控制点一�Q�控制点二，�l�结�?/li>
#include
rounded_rect(double x1, double y1, double x2, double r)
    对角点的坐标和圆角半�?/li>

至于怎样把他们画在渲染内存上呢，我们下一��会讲到�?/strong>
头文件也渐渐地多了�v来，包含头文件时的工作量有点大；我特地列了一个头文�g�Q�里面已�l�包含了所有的AGG头文�Ӟ��以后大家只需要包含它��好了�?br />下蝲处：http://m.shnenglu.com/Files/Shihira/agg.h.zip

Shihira 2012-07-24 16:30 发表评论

Shihira — Tue, 24 Jul 2012 08:30:00 GMT

学到目前为止�Q�已�l�认识了六个�c�d��Q?/div>

platform_support

rendering_buffer

rgba8

pixfmt_rgb24

rect_i

renderer_base

现在来做些练习，看看有没有掌握学�q�的东西�Q��ƈ且灵�z�运用吧�?/div>

一、基本框�?/h3>
�q�一节的�E�序都以�q�个框架为基��Q�都是在on_draw中稍微改动的�Q?/div>

#include
#include
#include

class the_application : public agg::platform_support
{
public:
    the_application(agg::pix_format_e format, bool flip_y) :
        agg::platform_support(format, flip_y),
        pix_fmt(rbuf_window()),
        ren_bas(pix_fmt) //初始化渲染器
    { }

    virtual void on_draw()
    {
   ren_bas.reset_clipping(true);
   ren_bas.clear(agg::rgba8(255, 255, 255));
    }
private:
    agg::pixfmt_rgb24 pix_fmt;
    agg::renderer_base ren_bas;

};

int agg_main(int argc, char* argv[])
{
    the_application app(agg::pix_format_bgr24, true);
    app.caption("AGG Test");

    if(app.init(500, 500, agg::window_resize)) {
        return app.run();
    }
    return -1;
}

二、画�U�函�?/h3>
�~�写如下函数�Q�实现在渲染�~�存中画�U�的功能�Q�无需反锯齿）�Q?br />     inline void stroke_line(int x1, int y1, int x2, int y2, agg::rgba8& color);
参数�Q?br />

x1, y1, x2, y2分别是两个端点的坐标�Q?/li>
color是颜�Ԍ��

三、画圆函�?/h3>
�~�写如下函数�Q�实现在渲染�~�存中画圆的功能�Q�无需反锯齿）�Q?br />     void stroke_round(int r, int C_x, int C_y, agg::rgba8& color, float step = 0.01)
参数�Q?br />

C_x, C_y 是圆心的坐标�Q?/li>
color是颜�Ԍ��

step是步长，也就是吧圆细分成1/step边�Ş�Q?

四、答�?/h3>

�ȝ��函数

inline void stroke_line(int x1, int y1, int x2, int y2, agg::rgba8& color)
{
    double precision = max(abs(x1 - x2), abs(y1 - y2));
    //�_�ֺ��Q�也��是��d��个�?/span>

    for(int i=0; i <= precision; i++)
        ren_bas.copy_pixel( x1 + ( x2 - x1 ) / precision * i, //x
            y1 + ( y2 - y1 ) / precision * i, //y
            color);
}

��d��函数

void stroke_round(int r, int C_x, int C_y, agg::rgba8& color, float step = 0.01)
{
    int prev_x = int(r * cos(-0.01)) + C_x,
        prev_y = int(r * sin(-0.01)) + C_y; //保存上一个点

    int x, y; //保存当前的点
    for(double rad = 0; rad < 2 * PI + step; rad+= step) {
        x = int(r * cos(rad)) + C_x;
        y = int(r * sin(rad)) + C_y; //计算弧度为rad时的坐标
        stroke_line(x, y, prev_x, prev_y, color);
        prev_x = x; prev_y = y;
    }
}

可能有的��Z��觉得奇怪的是，��Z��么在�ȝ��函数中，不用pix_fmt.copy_pixel()而用ren_bas.copy_pixel()呢？因�ؓ�Q�在pix_fmt中，混合器不�q�行��查，像素拯��的时候会拯��到剪裁区域以外，�q�样会造成很奇怪的情况�Q�以至于如果写到了缓存以外，�q�会出现异常。注意，剪裁盒功能是基础渲染器��别才提供的，更加底层的操作，比如像素格式混合和直接操作缓存，高层�ơ的渲染器是无从��理的。�ؓ了安全�v见，��碰基础渲染器以下的工具……

Shihira 2012-07-24 16:30 发表评论

Shihira — Tue, 24 Jul 2012 08:29:00 GMT

基础渲染器（Base Renderer�Q�是扫描�U�渲染器的基��Q�可以说�Q�正常情况下�Q�你�l�画��M��囑�Ş、做��M��事，都需要通过它。而基��渲染器需要你以模版的形式提供像素格式的信息，他将会通过像素格式混合器来实现渲染。其实，基础渲染器比像素格式混合器多了剪裁盒的功能，其他混合、拷贝什么的和像素格式�؜合器是相似的�Q�这里就不列出来了�?/div>
矩�Ş�c?/h3>
AGG��装了一个专门表�C�矩形的模板�c�rect_base�Q�方便矩形的操作。下面用rect_i说明一下�?
头文�?/h4>
#include "agg_basics.h"
�c�d��定义
typedef rect_base rect_i;
基本成员函数
rect_i(x1, y1, x2, y2)
构造函敎ͼ��l�出最��和最大坐标；
normalize()
  修正x1>x2或y1>y2的不合法矩�Ş�Q?/li>
clip(rect_i& r)
取当前矩形与r�怺�的区域矩形作为当前矩形；
is_valid()
��查矩形是否合法；
hit_test(int x, int y)
��?x, y)是否在矩形内�Q?/li>
基础渲染�?/h3>
头文�?/h4>
#include "agg_renderer_base"
�c�d��定义
template class renderer_base
基本成员函数
renderer_base(PixelFormat)
构造函敎ͼ�提供像素格式�Q?/li>
ren()
�q�回像素格式对象�Q?/li>
clip_box(x1,y1,x2,y2)
clip_box_naked(x1,y1,x2,y2)
讄��当前剪裁盒�ؓx1,y1,x2,y2围成的剪裁盒�Q�前者检查剪裁盒是否合法�Q�后者不��查�?/li>
reset_clipping(bool visibility)
重置剪裁盒，visibility军_��剪裁盒是铺满�H�口�Q�可视）�q�是0�Q�不可视�Q�；
clip_box()
xmin()
ymin()
xmax()
ymax()
�q�回当前剪裁盒矩形、以及纵横坐标；
copy_from()
blend_from()
可以比较方便地、以矩�Ş方式拯��和�؜合缓存里的图像了�Q?/li>

Shihira 2012-07-24 16:29 发表评论

AGG入门�Q�四�Q?- 渲染�~�存和�؜合器

Shihira — Tue, 24 Jul 2012 08:29:00 GMT

一、上一节的代码

agg::rendering_buffer &rbuf = rbuf_window();
        agg::pixfmt_rgb24 pixf(rbuf);

        agg::renderer_base renb(pixf);
        renb.clear(agg::rgba8(255, 255, 255));

        pixf.copy_pixel(20, 20, agg::rgba8(0, 0, 255));

二、渲染缓�?/h3>
渲染�~�存保存着一个个像素�Q�作为AGG的画布。它仅仅是一个内存块�Q�用来储存像素信息，不提供�Q何绘囑֊�能，只允�怽��d��和修攚w��面的数据。它也不告诉你里面的像素是灰度的、RGB的还是RGBA的，不告诉你从哪里到哪里是一个像�?#8212;—它只是用来管理内存数据的�?/div>
头文�?/h4>
#include "platform/agg_platform_support.h"

�c�d��定义

typedef row_accessor rendering_buffer //int8u�? bit无符��h��?/div>
基本成员函数

rendering_buffer(int8u* buf, unsigned width, unsigned height, int stride)
  构造函敎ͼ�指定事先分配好的内存块（到时��q��C��面）首地址、宽高、一行的字节敎ͼ�默认全部都是0�Q�；

row_ptr(int y)
  �q�回�W�y行的首地址�Q?/li>
copy_from(void *buf)
  从buf中拷贝像素；

clear(int8u value)
  用value清空�~�存

buf(), height(), weight(), stride()
  �q�回�~�存首地址、宽高、一行的字节敎ͼ�

注：代码中的rbuf_window()是platform_support的一个成员函敎ͼ�用于�q�回platform_support一开始帮你申��L��~�存引用�?/span>

三、�؜合器

混合器的存在是�ؓ了适应不同�q�_��、不同需求下的不同像素格式。�؜合器有三�U�：agg::rgba�Q?strong>agg::rgba8�?strong>agg::rgba16�Q�都是用来指定颜色的�Q�rgba每个通道储存为double�Q�rgba8为unsigned char�Q�rgba16为int或long int�Q��؜合器起到的作用就像Win32API里的RGB和COLORREF宏�?/div>
头文�?/h4>
#include "agg_pixfmt_rgba.h"

�c�d��定义

struct rgba8; //对，你没有看错，是结构，不是�c?#8230;…

基本成员函数

rgba8(unsigned r, unsigned g, unsigned b, unsigned a)
  无须解释了吧�Q�最�?55�Q?/li>
clear(), no_color()
  四个通道全部清零�Q�也��是变没色咯�Q?/li>
transparent()
  alpha清零�Q�变透明�Q?/li>
opacity()
  �q�回透明度，用double表示�Q?/li>
gradient(agg::rgba8 &c, double k)
  颜色梯度�Q�就是颜色变��Z��原先的颜色渐变�ؓc�Q�变化率为k�Q?/li>
add(agg::rgba8 &c, unsinged cover)
  颜色叠加�Q�叠加一个透明度�ؓcover/255的颜色c�Q?/li>

成员变量

r, g, b, a都是无符��h��型；

四、像素格式�؜合器

像素格式混合器的作用是直接操作像素（也就是缓存里保存的数据，但�v码有个像素的样子�Q�，起到Win32API里的SetPixel()和GetPixel()的作用。像素格式由两个属性决定：混合器类�?strong>【agg::rgba8/agg::rgba16�?/strong>、bgr/rgb/rgba/abgr��序【agg::order_bgr/agg::order_rgb/agg::order_rgba/agg::order_abgr�?/strong>——�q�样�Q�共8�U�像素格式，它们起名字的规则��是�Q?/div>

agg::pixfmt_[order][bits*3];

下面用最常用的agg::pixfmt_rgb24来解释：

头文�?/h4>
#include "agg_pixfmt_rgb.h"

�c�d��定义

typedef pixfmt_alpha_blend_rgb, rendering_buffer> pixfmt_rgb24;

基本成员函数

pixfmt_rgb24(agg::rendering_buffer &)
构造函敎ͼ�指定�~�存��好�Q?/li>
blend_pixel(agg::rgba8& c, int x, int y, int8u cover)
  用颜色c以cover�Q�覆盖率=透明度）的透明度�؜合像�?x, y)�Q?/li>
copy_pixel(agg::rgba8& c, int x, int y)�Q�pixel(int x, int y)
�q�个��是相当于SetPixel()和GetPixel()了；

copy_hline(int x, int y, unsigned len, agg::rgba8& c)
copy_vline(int x, int y, unsigned len, agg::rgba8& c)
  �?x, y)开始打横（竖）��序讄��len长度的像素；

blend_hline(int x, int y�Q?unsigned len, agg::rgba8& c, int8u cover)
blend_vline(int x, int y�Q?unsigned len, agg::rgba8& c, int8u cover)
  �?x, y)开始打横（竖）��序混合len长度的像素；

copy_solid_hspan(int x, int y�Q?unsigned len, agg::rgba8* colors)
copy_solid_vspan(int x, int y�Q?unsigned len, agg::rgba8* colors)
blend_solid_hspan(int x, int y�Q?unsigned len, agg::rgba8* colors, int8u* cover, int8u cover)
blend_solid_vspan(int x, int y�Q?unsigned len, agg::rgba8* colors, int8u* cover, int8u cover)
  同上两个�Q�不�q�不是一个颜�Ԍ��是一�p�d��的颜�Ԍ��

for_each_pixel(void (*f)(agg::rgba8* color))
  每一像素执行一遍f�Q?/li>
copy_from(agg::rendering_buffer & from, int xdst, int ydst, int xsrc, int ysrc, unsigned len)
blend_from(agg::rendering_buffer & from, int xdst, int ydst, int xsrc, int ysrc, unsigned len[, unsigned cover])
  从缓存form�?xsrc, ysrc)��序复制�Q��؜合）到当前缓存的(xdst, ydst)中；

【其他函数和像素格式��p��靠大家的举一反三�Q�触�c�L��通了……�?/div>

五、结�?/h3>
上面说的三者关�p�L��Q��؜合器混合RGBA四个通道�Q�像素格式�؜合器混合像素�Q�像素格式�؜合器操作的结果是使渲染缓存里的数据发生变化，而�؜合器则不会，因�ؓ它的作用仅仅是表�C�颜艌Ӏ?/div>

Shihira 2012-07-24 16:29 发表评论

Shihira — Tue, 24 Jul 2012 08:28:00 GMT

一、看回AGG入门�Q�二�Q�时on_draw()虚函数里的代码：

agg::rendering_buffer &rbuf = rbuf_window();
        agg::pixfmt_rgb24 pixf(rbuf);

        agg::renderer_base renb(pixf);
        renb.clear(agg::rgba8(255, 255, 255));

        pixf.copy_pixel(20, 20, agg::rgba8(0, 0, 255));

二、渲染器

什么是渲染�Q?/h4>
渲染是把内存中的�l�图指��o真正执行的过�E�。比如说�Q�绘制一条线�D�，在内存里只会保存着两个端点的坐标和�U�段的宽度，而渲染就把这两个端点转换��Z��图、缓存甚��x��C�屏上的一个个像素的数据。又比如��_��U�R��Z��面肯定是要有投媄的了�Q�但�q�个投媄的质量，��q��渲染器决定；�U�段是走��L��Q�A�Q�，�q�是反走��L��Q�B�Q�，靠的��是渲染器的指��o了�?br />

AGG里的渲染�?/h4>
AGG分有多种渲染器。在AGG中，渲染器负责表现扫描线中的每个�U�段。在渲染器之前，AGG囑�Ş中的�U�段是没有颜色值的�Q�只是位�|�、长度和覆盖率（透明度）。渲染器赋于�U�段色彩�Q�最�l�成��Z��q�完整的囑փ�。其中最常用的是�Q?/div>

像素格式渲染�?/li>
基础渲染�?/li>
扫描�U�（反锯齿）渲染�?/li>

三、三�U�渲染器间的关系

像素格式渲染器（PixelFormat Renderer�Q�是最基础的渲染器�Q�不需要�Q何其他渲染器的支持，所以可以直接声明；

基础渲染器（Base Renderer�Q�是中��渲染器，需要像素格式作为模版和像素格式渲染器的支持;

扫描�U�渲染器�Q�Scanline Renderer�Q�是高��渲染器，需要基��渲染器作为模版和支持;

�Q�注�Q�模版主要是��Z��获取像素格式的信息）

所以，除像素格式渲染器声明为：
agg::class object(agg::rendering_buffer &);
之外其他的渲染器都声明�ؓ�Q?/div>
agg::class

久久久精品久久久久久,久久久91精品国产一区二区三区,99久久免费国产特黄

AGG入门�Q�八�Q?- 渲染

一、引�a�

二、顶�Ҏ��

三、内�|�顶�Ҏ��

四、�\径储存器

头文�?/h4> #include

�c�d��定义

基本成员函数

五、其他顶�Ҏ��

矩�Ş�c?/h3>AGG���装了一个专门表�C�矩形的模板�c�rect_base�Q�方便矩形的操作。下面用rect_i说明一下�?

头文�?/h4>#include "agg_basics.h"

�c�d��定义

基本成员函数

基础渲染�?/h3>

头文�?/h4>#include "agg_renderer_base"

�c�d��定义

基本成员函数

AGG入门�Q�四�Q?- 渲染�~�存和�؜合器

一、上一节的代码

头文�?/h4> #include "platform/agg_platform_support.h"

�c�d��定义

基本成员函数

三、�؜合器

头文�?/h4> #include "agg_pixfmt_rgba.h"

�c�d��定义

基本成员函数

成员变量

四、像素格式�؜合器

头文�?/h4> #include "agg_pixfmt_rgb.h"

�c�d��定义

基本成员函数

一、看回AGG入门�Q�二�Q�时on_draw()虚函数里的代码：

二、渲染器

三、三�U�渲染器间的关系

一、准�?/h3> �?http://www.antigrain.com/download/index.html下蝲源码包�?/li> 今天用Visual C++ 6.0来做IDE和编译器啦！要多�l�典有多�l�典�?/li>

AGG入门�Q�二�Q?- �q�_��支持

一、先看看下面的代码，�q�试着�~�译下：

�c�d��

主要成员函数

虚函敎ͼ�一般都是些消息�Q�要覆盖它以让消息��@环调用）

头文�?/h4>
#include

矩�Ş�c?/h3>
AGG��装了一个专门表�C�矩形的模板�c�rect_base�Q�方便矩形的操作。下面用rect_i说明一下�?

头文�?/h4>
#include "agg_basics.h"

头文�?/h4>
#include "agg_renderer_base"

头文�?/h4>
#include "platform/agg_platform_support.h"

头文�?/h4>
#include "agg_pixfmt_rgba.h"

头文�?/h4>
#include "agg_pixfmt_rgb.h"

一、准�?/h3>

�?http://www.antigrain.com/download/index.html下蝲源码包�?/li>
今天用Visual C++ 6.0来做IDE和编译器啦！要多�l�典有多�l�典�?/li>