自制操作系统10-图层叠加处理

最新推荐文章于 2023-05-31 17:32:20 发布
最新推荐文章于 2023-05-31 17:32:20 发布
阅读量407 收藏
点赞数
分类专栏： 自制操作系统 文章标签： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45177370/article/details/109311027
版权

10 图层叠加处理

2020.10.23-2020.10.24

今天实现了画面中窗口的叠加解决了鼠标吃任务栏的问题，还相应地提高了画面刷新的速度。

1. 叠加处理

文档：harib07b

现在我们继续回到上次鼠标显示的问题上，上次鼠标移动到下面后把任务栏给吃了。

所以我们要处理画面叠加显示的问题，不仅适用于鼠标还要适用于多窗口的叠加。

image-20201027131620024

我们决定使用图层来存放窗口，通过移动图层的方法实现鼠标指针的移动以及窗口的移动。

先定义图层结构体

struct SHEET {
	unsigned char *buf;
	int bxsize, bysize, vx0, vy0, col_inv, height, flags;
}
  • buf用来记录图层所画内容的地址。
  • bxsize和bysize指定图层大小。
  • vx0和vy0指定图层在画面上的坐标。
  • col_inv表示透明色色号（color_invisable)。
  • height表示图层高度。
  • flags存放图层的设定信息。

接着创建一个管理多个图层的结构体

#define MAX_SHEETS 256

struct SHTCTL {
    unsigned char *vram;
    int xsize, ysize, top;
    struct SHEET *sheets[MAX_SHEETS];
    struct SHEET sheets0[MAX_SHEETS];
};

  • 我们把图层上限MAX_SHEETS设置为256。

  • vram、xsize、ysize代表VRAM的地址和画面大小，每次都从BOOTINFO查询就太麻烦了，所以我们直接把他记录在结构体中。

  • top记录最上面的图层高度。

  • sheets0用来存放图层信息，sheets记忆图层地址。sheets0中的图层顺序是混乱的，将它们按顺序升序排列后将地址写入sheets中。

    image-20201027131744359

图层控制变量中，sheets0占内存32B * 256 = 8192B = 8KB，sheets占4B * 256 = 1024B =1KB，对于空间需要如此大的变量我们需要使用memman_alloc_4k来分配内存空间，因此我们需要编写对内存空间进行分配和初始化的函数。

//本次的*sheet.c节选

struct SHTCTL *shtctl_init(struct MEMMAN *memman, unsigned char *vram, int xsize, int ysize)
{
    struct SHTCTL *ctl;
    int i;
    ctl = (struct SHTCTL *) memman_alloc_4k(memman, sizeof (struct SHTCTL));
    if (ctl == 0) {
    	goto err;
    }
    ctl->vram = vram;
    ctl->xsize = xsize;
    ctl->ysize = ysize;
    ctl->top = -1; /*一个SHEET没都有 */
    for (i = 0; i < MAX_SHEETS; i++) {
    	ctl->sheets0[i].flags = 0; /* 标记为未使用 */
    }
    err:
    return ctl;
}

先使用memmen_alloc_4k分配内存空间，我们使用sizeof(struct SHTCTL)来计算空间大小。（ sizeof（变量类型）可以让C编译器自动计算该变量类型所需的字节数），然后对变量进行初始化并对所有图层加上“未使用”标签。

取得新生成的未使用的图层

//本次的*sheet.c节选

#define SHEET_USE 1

struct SHEET *sheet_alloc(struct SHTCTL *ctl)
{
    struct SHEET *sht;
    int i;
    for (i = 0; i < MAX_SHEETS; i++) {
        if (ctl->sheets0[i].flags == 0) {
            sht = &ctl->sheets0[i];
            sht->flags = SHEET_USE; /* 标记为正在使用*/
            sht->height = -1; /* 隐藏 */
            return sht;
        }
    }
    return 0; /* 所有的SHEET都处于正在使用状态*/
}

在sheets0[ ]中寻找未使用的图层，找到后标记为“正在使用”并返回其地址。

程序中出现的&ctl->sheets0[i]是“ctl->sheets0[i]的地址”的意思。也就是说，指的是&（ctl->sheets0[i]），而不是（&ctl）-> sheets0[i]。

设定图层的缓冲区、大小和透明色的函数

//本次的*sheet.c节选

void sheet_setbuf(struct SHEET *sht, unsigned char *buf, int xsize, int ysize, int col_inv)
{
    sht->buf = buf;
    sht->bxsize = xsize;
    sht->bysize = ysize;
    sht->col_inv = col_inv;
    return;
}

设定图层高度的函数

//本次的*sheet.c节选

void sheet_updown(struct SHTCTL *ctl, struct SHEET *sht, int height)
{
    int h, old = sht->height; /* 存储设置前的高度信息 */
    
    /* 如果指定的高度过高或过低，则进行修正 */
    if (height > ctl->top + 1) {
    	height = ctl->top + 1;
    }
    if (height < -1) {
    	height = -1;
    }
    sht->height = height; /* 设定高度 */
    
    /* 下面主要是进行sheets[ ]的重新排列 */
    if (old > height) { /* 比以前低 */
        if (height >= 0) {
        	/* 把中间的往上提 */
            for (h = old; h > height; h--) {
            	ctl->sheets[h] = ctl->sheets[h - 1];
            	ctl->sheets[h]->height = h;
        	}
        	ctl->sheets[height] = sht;
        } else { /* 隐藏 */
            if (ctl->top > old) {
                /* 把上面的降下来 */
                for (h = old; h < ctl->top; h++) {
                	ctl->sheets[h] = ctl->sheets[h + 1];
                	ctl->sheets[h]->height = h;
                }
            }
        	ctl->top--; /* 由于显示中的图层减少了一个，所以最上面的图层高度下降 */
        }
        sheet_refresh(ctl); /* 按新图层的信息重新绘制画面 */
    } else if (old < height) { /* 比以前高 */
        if (old >= 0) {
            /* 把中间的拉下去 */
            for (h = old; h < height; h++) {
            	ctl->sheets[h] = ctl->sheets[h + 1];
            	ctl->sheets[h]->height = h;
            }
            ctl->sheets[height] = sht;
        } else { /* 由隐藏状态转为显示状态 */
            /* 将已在上面的提上来 */
            for (h = ctl->top; h >= height; h--) {
            	ctl->sheets[h + 1] = ctl->sheets[h];
            	ctl->sheets[h + 1]->height = h + 1;
            }
            ctl->sheets[height] = sht;
            ctl->top++; /* 由于已显示的图层增加了1个，所以最上面的图层高度增加 */
        }
        sheet_refresh(ctl); /* 按新图层信息重新绘制画面 */
    }
    return;
}

sheet_updown中的sheet_refresh函数会从下到上描绘所有的图层。

画面刷新的函数

//本次的*sheet.c节选

void sheet_refresh(struct SHTCTL *ctl)
{
    int h, bx, by, vx, vy;
    unsigned char *buf, c, *vram = ctl->vram;
    struct SHEET *sht;
    for (h = 0; h <= ctl->top; h++) {
        sht = ctl->sheets[h];
        buf = sht->buf;
        for (by = 0; by < sht->bysize; by++) {
            vy = sht->vy0 + by;
            for (bx = 0; bx < sht->bxsize; bx++) {
                vx = sht->vx0 + bx;
                c = buf[by * sht->bxsize + bx];
                if (c != sht->col_inv) {
                	vram[vy * ctl->xsize + vx] = c;
                }
            }
        }
    }
    return;
}

从上往上，将透明以外的所有像素都复制到VRAM上中，最后最上面的内容就留在了画面上。

图层滑动函数

//本次的*sheet.c节选

void sheet_slide(struct SHTCTL *ctl, struct SHEET *sht, int vx0, int vy0)
{
    sht->vx0 = vx0;
    sht->vy0 = vy0;
    if (sht->height >= 0) { /* 如果正在显示*/
    	sheet_refresh(ctl); /* 按新图层的信息刷新画面 */
    }
    return;
}

释放已使用图层的内存的函数

//本次的*sheet.c节选

void sheet_free(struct SHTCTL *ctl, struct SHEET *sht)
{
    if (sht->height >= 0) {
    	sheet_updown(ctl, sht, -1); /* 如果处于显示状态，则先设定为隐藏 */
    }
    sht->flags = 0; /* "未使用"标志 */
    return;
}

将以上与图层有关的函数都汇总到sheet.c中。

改造HariMain函数

//本次的*bootpack.c节选

void HariMain(void)
{
    （中略）
    struct SHTCTL *shtctl;
    struct SHEET *sht_back, *sht_mouse;
    unsigned char *buf_back, buf_mouse[256];
    （中略）
        
    init_palette();
    shtctl = shtctl_init(memman, binfo->vram, binfo->scrnx, binfo->scrny);
    sht_back = sheet_alloc(shtctl);
    sht_mouse = sheet_alloc(shtctl);
    buf_back = (unsigned char *) memman_alloc_4k(memman, binfo->scrnx * binfo->scrny);
    sheet_setbuf(sht_back, buf_back, binfo->scrnx, binfo->scrny, -1); /* 没有透明色 */
    sheet_setbuf(sht_mouse, buf_mouse, 16, 16, 99); /* 透明色号99 */
    init_screen8(buf_back, binfo->scrnx, binfo->scrny);
    init_mouse_cursor8(buf_mouse, 99); /* 背景色号99 */
    sheet_slide(shtctl, sht_back, 0, 0);
    mx = (binfo->scrnx - 16) / 2; /* 按显示在画面中央来计算坐标 */
    my = (binfo->scrny - 28 - 16) / 2;
    sheet_slide(shtctl, sht_mouse, mx, my);
    sheet_updown(shtctl, sht_back, 0);
    sheet_updown(shtctl, sht_mouse, 1);
    sprintf(s, "(%3d, %3d)", mx, my);
    putfonts8_asc(buf_back, binfo->scrnx, 0, 0, COL8_FFFFFF, s);
    sprintf(s, "memory %dMB free : %dKB", memtotal / (1024 * 1024), memman_total(memman) / 1024);
    putfonts8_asc(buf_back, binfo->scrnx, 0, 32, COL8_FFFFFF, s);
    sheet_refresh(shtctl);
    
    for (;;) {
        io_cli();
        if (fifo8_status(&keyfifo) + fifo8_status(&mousefifo) == 0) {
        	io_stihlt();
        } else {
            if (fifo8_status(&keyfifo) != 0) {
                i = fifo8_get(&keyfifo);
                io_sti();
                sprintf(s, "%02X", i);
                boxfill8(buf_back, binfo->scrnx, COL8_008484, 0, 16, 15, 31);
                putfonts8_asc(buf_back, binfo->scrnx, 0, 16, COL8_FFFFFF, s);
                sheet_refresh(shtctl);
            } else if (fifo8_status(&mousefifo) != 0) {
                i = fifo8_get(&mousefifo);
                io_sti();
                if (mouse_decode(&mdec, i) != 0) {
                    /* 因为已得到3字节的数据所以显示 */
                    sprintf(s, "[lcr %4d %4d]", mdec.x, mdec.y);
                    if ((mdec.btn & 0x01) != 0) {
                    	s[1] = 'L';
                    }
                    if ((mdec.btn & 0x02) != 0) {
                   		s[3] = 'R';
                    }
                    if ((mdec.btn & 0x04) != 0) {
                    	s[2] = 'C';
                    }
                    boxfill8(buf_back, binfo->scrnx, COL8_008484, 32, 16, 32 + 15 * 8 - 1, 31);
                    putfonts8_asc(buf_back, binfo->scrnx, 32, 16, COL8_FFFFFF, s);
                    /* 移动光标 */
                    mx += mdec.x;
                    my += mdec.y;
                    if (mx < 0) {
                    	mx = 0;
                    }
                    if (my < 0) {
                    	my = 0;
                    }
                    if (mx > binfo->scrnx - 16) {
                    	mx = binfo->scrnx - 16;
                    }
                    if (my > binfo->scrny - 16) {
                    	my = binfo->scrny - 16;
                    }
                    sprintf(s, "(%3d, %3d)", mx, my);
                    boxfill8(buf_back, binfo->scrnx, COL8_008484, 0, 0, 79, 15); /* 消坐标 */
                    putfonts8_asc(buf_back, binfo->scrnx, 0, 0, COL8_FFFFFF, s); /* 写坐标 */
                    sheet_slide(shtctl, sht_mouse, mx, my); /* 包含sheet_refresh含sheet_refresh */
                }
            }
        }
    }
}

准备了2个图层，分别是sht_back和sht_mouse，还准备了2个缓冲区buf_back和buf_mouse，用于在其中描绘图形。以前我们指定为binfo->vram的部分，现在有很多都改成了buf_back。而且每次修改缓冲区之后都要刷新。

测试一下程序

image-20201027140535602

剩余内存减少了一些，但是鼠标已经不会吃任务栏了。但是我们移动鼠标非常不顺畅，这个问题也得解决！

2. 提高叠加处理速度

文档：harib07d

**要怎么样才能提高速度呢？**我们从鼠标指针的移动也就是图层的移动来思考一下。

鼠标虽然只有16 * 16 = 256个像素，但是根据harib07b的程序，只要它稍微移动程序就需要对整个画面进行刷新。实际上，我们只需要刷新鼠标移动前后的部分就可以了，即256 * 2 = 512个像素。占总像素64000的0.8%，这样肯定能大幅提速。

//本次的*sheet.c节选

void sheet_refreshsub(struct SHTCTL *ctl, int vx0, int vy0, int vx1, int vy1)
{
    int h, bx, by, vx, vy, bx0, by0, bx1, by1;
    unsigned char *buf, c, *vram = ctl->vram;
    struct SHEET *sht;
    for (h = 0; h <= ctl->top; h++) {
        sht = ctl->sheets[h];
        buf = sht->buf;
        /* 使用vx0～vy1，对bx0～by1进行倒推 */
        bx0 = vx0 - sht->vx0;
        by0 = vy0 - sht->vy0;
        bx1 = vx1 - sht->vx0;
        by1 = vy1 - sht->vy0;
        if (bx0 < 0) { bx0 = 0; } /* 说明(1) */
        if (by0 < 0) { by0 = 0; }
        if (bx1 > sht->bxsize) { bx1 = sht->bxsize; } /* 说明(2) */
        if (by1 > sht->bysize) { by1 = sht->bysize; }
        for (by = by0; by < by1; by++) {
            vy = sht->vy0 + by;
            for (bx = bx0; bx < bx1; bx++) {
                vx = sht->vx0 + bx;
                c = buf[by * sht->bxsize + bx];
                if (c != sht->col_inv) {
                	vram[vy * ctl->xsize + vx] = c;
                }
            }
        }
    }
    return;    
}

使用(vx0,vy0)和(vx1,vy1)来指定刷新的范围。

bx在for语句中在bx0到bx1之间循环（对于by也一样）。而bx0和bx1都是从刷新范围“倒推”求得的。倒推其实就是把公式变形转换了一下，具体如下：vx = sht->vx0 + bx; => bx = vx - sht->vx0;

vx0是相对于整个画面的坐标，bx0是图层内的坐标。

说明（1）：在sht_back中写入字符并进行刷新，而刷新范围的一部分刚好被鼠标覆盖

image-20201027144130694

这种情况下，其实鼠标图层需要刷新的范围只需要重叠的那一小部分，不需要刷新其余地方。所以我们把（bx0，by0）置为（0，0）。

image-20201027144215322

说明（2）同理

image-20201027144634310

第三种情况 完全不重叠的时候，bx0和bx1都是负值，经过if后只有bx0被修正，修正后为0，for(bx = bx0; bx < bx1; bx++)中的 bx<bx1从一开始就不成立，所以完全不会进行重绘。

使用sheet_refreshsub函数来提高sheet_slide的运行速度

//本次的*sheet.c节选

void sheet_slide(struct SHTCTL *ctl, struct SHEET *sht, int vx0, int vy0)
{
    int old_vx0 = sht->vx0, old_vy0 = sht->vy0;
    sht->vx0 = vx0;
    sht->vy0 = vy0;
    if (sht->height >= 0) { /* 如果正在显示，则按新图层的信息刷新画面 */
   		sheet_refreshsub(ctl, old_vx0, old_vy0, old_vx0 + sht->bxsize, old_vy0 + sht->bysize);
    	sheet_refreshsub(ctl, vx0, vy0, vx0 + sht->bxsize, vy0 + sht->bysize);
    }
    return;
}

重新刷新移动前和移动后的地方就可以了。

移动鼠标时，由于要在画面上显示坐标等信息，所以又执行了了sheet_refresh程序，所以还是很慢。下面我们就来解决一下图层内文字显示的问题。

显示文字时，实际上我们也不用刷新整个图层，实际上只需要刷新显示文字处的像素即可。下面就重新编写一下sheet_refresh。

//本次的*sheet.c节选

void sheet_refresh(struct SHTCTL *ctl, struct SHEET *sht, int bx0, int by0, int bx1, int by1)
{
    if (sht->height >= 0) { /* 如果正在显示，则按新图层的信息刷新画面*/
    	sheet_refreshsub(ctl, sht->vx0 + bx0, sht->vy0 + by0, sht->vx0 + bx1, sht->vy0 + by1);
    }
    return;
}

这里指定范围，我们是直接指定图层内的坐标，这样就可以不用考虑图层在画面中的位置了。

由于改动了refresh，所以也要相应改造updown函数中的refresh函数的参数。

最后改写一下HariMain

本次的*bootpack.c节选
void HariMain(void)
{
    （中略）
    sprintf(s, "(%3d, %3d)", mx, my);
    putfonts8_asc(buf_back, binfo->scrnx, 0, 0, COL8_FFFFFF, s);
    sprintf(s, "memory %dMB free : %dKB", memtotal / (1024 * 1024), memman_total(memman) / 1024);
    putfonts8_asc(buf_back, binfo->scrnx, 0, 32, COL8_FFFFFF, s);
    sheet_refresh(shtctl, sht_back, 0, 0, binfo->scrnx, 48); /* 这里！ */
    
    for (;;) {
        io_cli();
        if (fifo8_status(&keyfifo) + fifo8_status(&mousefifo) == 0) {
        	io_stihlt();
        } else {
            if (fifo8_status(&keyfifo) != 0) {
            	（中略）
            	sheet_refresh(shtctl, sht_back, 0, 16, 16, 32); /* 这里！ */
            } else if (fifo8_status(&mousefifo) != 0) {
                i = fifo8_get(&mousefifo);
                io_sti();
                if (mouse_decode(&mdec, i) != 0) {
                    （中略）
                    boxfill8(buf_back, binfo->scrnx, COL8_008484, 32, 16, 32 + 15 * 8 - 1, 31);
                    putfonts8_asc(buf_back, binfo->scrnx, 32, 16, COL8_FFFFFF, s);
                    sheet_refresh(shtctl, sht_back, 32, 16, 32 + 15 * 8, 32); /* 这里！ */
                    （中略）
                    sprintf(s, "(%3d, %3d)", mx, my);
                    boxfill8(buf_back, binfo->scrnx, COL8_008484, 0, 0, 79, 15); /* 消去坐标 */
                    putfonts8_asc(buf_back, binfo->scrnx, 0, 0, COL8_FFFFFF, s); /* 写出坐标 */
                    sheet_refresh(shtctl, sht_back, 0, 0, 80, 16); /* 这里！ */
                    sheet_slide(shtctl, sht_mouse, mx, my);
                }
            }
        }
    }
}

测试一下画面流畅度

image-20201027144847175

这次舒服多了，现在的haribote.sys也已经11104B了，大约是10.8KB。

明天见！

Lor :)
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C#图片处理总结——叠加、缩放、鼠标拖动
zhaochunyang2000的专栏
05-03 6613
<br />/////////////用到的命名空间////////////<br />using System.Drawing;<br />using System.Drawing.Drawing2D;<br />using System.Drawing.Imaging; <br />/////两张图片叠加，float fImage（0—1）透明度///////////////<br /> private void getMixImage(float fImage, string strFrontImag
30天自制操作系统之叠加处理
超胆孤侠
08-01 286
前言 我们通过往显存Vram里面直接设置像素的颜色来设置显示某个对象 对于数字或者字母，我们将其显示放置在一个16*16的数组当中，然后将其遍历，显示在画面的某个位置 static char cursor[16][16] = { "**************..", "*OOOOOOOOOOO*...", "*OOOOOOOOOO*....", "*OOOOOOOOO*......
[读书笔记]30 天自制操作系统 day10 叠加处理
zhyh1435589631的专栏
12-19 544
1. 内存管理 虽然我们采用列表式管理， 但是由于我们的列表的条目是非常有限的，如果不经约束的进行内存的分配和释放的话， 可能会造成在内存中出现有很多不连续的小段的未使用空间， 这样就容易会把内存空间耗尽 我们采用的方式是通过以 0x1000 字节（4KB） 作为单位进行管理 3.内存管理相关代码： 内存分配的时候， 从前向后遍历， 找到第一块满足需要的内存块进行操作即可 通过4KB 为单位进行
自制操作系统（十） 图像叠加处理
weixin_30536513的博客
07-12 177
2016.07.12 参考书籍：《30天自制操作系统》、《自己动手写操作系统》 qq:992591601 欢迎交流 图像叠加处理的原理很简单，就是给图像分层，从低下往上面画，便可以实现叠加的效果。例如，屏幕背景+一个窗口+鼠标的情况。 例如下面的情形： 计算机桌面上有三个窗口程序，A、B、C。B位于A之上，C位于B之上。要实现这种效果，只需要，先画A...
20.优化图层叠加处理
Zllvincent的博客
11-23 8594
简介 上节实现了图层叠加处理但是在移动鼠标时消耗了大量的cpu资源导致鼠标滑动不流畅。 目标 为了让cpu不消耗大量的计算资源在鼠标移动重新绘制界面上，我们采用局部绘制的方式减小系统资源消耗。例如鼠标从(0,0)移动到(1,1)位置，只需要绘制开始鼠标大小位置和终点鼠标大小，共计16x16x2x图层数 = 512x图层数量。系统消耗为 512x图层数量 / (320x200x图层数量) ，即消耗...
C#叠加图片的简单代码
rell336的专栏
12-30 3139
//pictureBox1的图案为背景，pictureBox2放于背景上，形成pictureBox3的图案 private void button3_Click(object sender, EventArgs e) { Image imgBackgroud = pictureBox1.Image; //背景图 Image imgForegroud = pictureBox2.Image; //前景图 ...
30天自制操作系统第10天
xiaoana_139的博客
01-02 866
操作系统实验日志10 第10天：叠加处理 30天自制操作系统第10天操作系统实验日志10一、实验主要内容1、 内容1：内存管理2、 内容2：叠加处理3、 内容3：提高叠加处理速度14、 内容4：提高叠加处理速度2二、遇到的问题及解决方法三、程序设计创新点四、实验心得体会 一、实验主要内容 1、 内容1：内存管理 为了减少内存碎片，我们要编写一些以4kb为单位进行分配和释放的函数，把指定的...
碎片图像无缝拼合技术的VC++实现
phphot
03-14 1717
一、 引言   在 测绘、文博等行业经常会遇到这样一种情况：观测对象比较大，为保证分辨率又不能将其全部照下，只能进行局部照相，事后再将这些局部照相的重合部分去掉，拼 合成一幅完整的图像。以前多采用手工拼合，误差较大，往往不能很好的实现无缝拼
C# 多个图片叠加,图片透明.
思月行云
10-10 5880
  下载该示例代码     文章出处：http://www.cnblogs.com/kaixin110/archive/2007/08/04/841827.html using System;using System.Collections.Generic;using System.Text;using System.Collections;using System.Drawi
C#-------Graphics
weixin_30673715的博客
01-17 182
转自：http://listsetio090529.blog.163.com/blog/static/1327321842010479331240/ 所有通过GDI+绘制的工作都会涉及到Graphics对象，下面列举几种使用到它的场景：1. 在绘制过程中，Windows Form控件会通过OnPaint和OnPaintBackground方法传递PaintEventArgs参数，而Graphic...
c#实现几个图片叠加到一起
05-05
用c#做的windows桌面程序，实现了几个图片叠加到了一起。
C#下用GDAL对多景单幅影像进行图层叠加操作
02-02
内含所有源代码，对于利用GDAL进行多幅影像进行图层叠加的小伙伴会有参考的，可能会有不足，但是代码是自己花了多半天弄出来的（VS2010 ），需要的朋友拿走把。效率挺高的，个人测试超过了ENVI的Layer Stacking效率。
C# Graphics 实现双缓冲多图层
最新发布
Riccccc的博客
05-31 1045
所以这个锁另外一个位置是加在MyGraphics类里面的，简易版myGraphics类中获取layer返回的是bitmap对象，实际上我每次获取到bitmap对象之后100%会转化为graphics对象，所以在此处我直接新写了一个方法，直接给我返回某个图层的Graphics 对象，并且在里面添加了事件。我的代码中订阅的是转换坐标系的操作，每次我获取Graphics 对象后，会主动转换坐标系，这个与主题无关，只是随口一提，可以无视。这个方法的参数是重新绘制的区域，区域外的内容其不去更新。
C#的简单图片透明处理
Hermit的专栏
12-29 8666
代码在WinXP和WinCE5.0都可以使用。作用是2幅图叠加的时候，背景图不变，前景图指定颜色做透明处理。使用到的是SetColorKey来设置透明色。            Graphics g = this.CreateGraphics();            Bitmap bitmap = new Bitmap(@"E:/xxx/testb.png");          
留个档，C# AlphaBlend，带Alpha通道的图片的叠加
神一般的狄狄的小黑屋
08-10 688
C# AlphaBlend，带Alpha通道的图片的叠加
background图片叠加,C＃将图像叠加在另一个图像上
weixin_33918358的博客
02-23 870
i am currently trying to put the notes on top of the staff image. However, the notes background are being set to the form background as shown in the image.image type used is png.//class music staffpub...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Lor :)

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值