2019-02-23 14:18:02 qq_15295565 阅读数 1653
  • Java经典算法讲解

    在面试中,算法题目是必须的,通过算法能够看出一个程序员的编程思维,考察对复杂问题的设计与分析能力,对问题的严谨性都能够体现出来。一个算法的好坏,直接影响一个方法调用的性能,进而影响软件的整体性能。算法是学习所有编程语言的基础,在Java的学习过程中首先也会选择以算法起步,本次课程重点讲解Java开发中常用的基本算法。

    29964 人正在学习 去看看 张中强

导语:很多时候,我们需要对一个图像的局部进行调整,这个调整必须是平滑的和可交互式的。Photoshop液化滤镜中向前变形工具就是这样一个工具,很好用。类似工具有美图秀秀(http://xiuxiu.meitu.com/)的瘦脸功能。本文描述这类工具背后的原理与算法。

先以美图秀秀为例子,简单描述下向前变形功能。

首先,用鼠标控制一个圆形的选区。

然后,点击鼠标左键,向某个方向拖动,就可以产生光滑的向前变形图片:

通过这个工具,可对图片的局部进行调整,自由度比较大,因此比较实用。

主要参考:交互式图像变形算法一文 。看过该文章后,自然了解瘦脸其实用的是图像局部平移变形,放大眼睛,用的是图像局部缩放变形。同时,文章还阐述了图像局部旋转变形的算法原理及思路。

 

瘦脸及放大眼睛的前提是需要检测到人脸,并提取特征点。谈到图像变形,最基础的思路是:由变形前坐标,根据变形映射关系,得到变形后坐标。这其中变形映射关系是最关键的,不同的映射关系,将得到不同的变形效果。平移、缩放、旋转,对应的是不同的映射关系,即不同的变换公式。当然实际在计算过程中,用的是逆变换,即由变形后坐标,根据逆变换公式反算变形前坐标,然后插值得到该坐标rgb像素值,将该rgb值作为变形后坐标对应的像素值。这样才能保证变形后的图像是连续、完整的。

 

下面讲讲这类算法的原理。

上图中,阴影圆环代表一个半径为 rmax 的圆形选区。其中,C点是鼠标点下时的点,也就是圆形选区的圆心。鼠标从C拖到M,致使图像中的点U变换到点X。所以,关键问题是找到上面这个变换的逆变换——给出点X时,可以求出它变换前的坐标U(精确的浮点坐标),然后用变化前图像在U点附近的像素进行插值,求出U的像素值。如此对圆形选区内的每一个像素进行求值,便可得出变换后的图像。

Andreas Gustafsson 的 Interactive Image Warping 一文给出了这一逆变换公式:

公式中,由于主要是像素点位置计算,因此涉及一些矢量运算,不过比较简单。其实上面公式就是逆变换公式了,x是变换后的位置,u是原坐标位置。整个计算在以c为圆心,r为半径的圆内进行。因为是交互式图像局部变形,所以c也可以看做鼠标点下时的坐标,而m为鼠标移动一段距离后抬起时的坐标,这样c和m就决定了变形方向。下面是示例代码,公式结合代码一起看,应该很快能弄明白。

 

这个变形算法的特点是:

1 只有圆形选区内的图像才进行变形

2 越靠近圆心,变形越大,越靠近边缘的变形越小,边界处无变形

3 变形是平滑的

具体实现步骤如下:

1 对于圆形选区里的每一像素,取出其R,G,B各分量,存入3个Buff(rBuff, gBuff, bBuff)中(也即,三个Buff分别存储选区内的原图像的R,G,B三个通道的数值)

2 对于圆形选区里的每一个像素X,

2.1 根据上面的公式,算出它变形前的位置坐标精确值U

2.2 用插值方法,根据U的位置,和rBuff, gBuff, bBuff中的数值,计算U所在位置处的R,G,B等分量

2.3 将R,G,B等分量合成新的像素,作为X处的像素值

代码我就不贴了,真正对这功能有需求的,根据上面的文字可以很容易写出来——解决这类问题,重要的不是代码,而是思路和算法。

下面是我的实现演示:

 

上图中,左上角是原图,右下角是变形后的图。红色圆圈圈起来的是变形区域。可以看见,变形很光滑。我在上面的算法中引入了变形强度s(strength),上图中strength=20。

引入strength,公式就得修改下,下面是我的修改版公式:

看看结果——

原图:

变形,strength=20:

变形,strength=120:

 

photoshop与美图秀秀里这个功能可以连续的进行变形。我猜测,这个连续的变形是由一系列基础变形串联起来的,也就是,鼠标从M0拖到Mn位置,并不是只计算M0->Mn这个变换,而是在鼠标轨迹上引入一系列中间点,M1,M2…Mn-1,然后,对图像进行M0->M1,M1->M2,…,Mn-1->Mn等一系列变换。

函数功能实现

void LocalTranslationWarp(Mat &img, int warpX, int warpY, int warpW, int warpH, int directionX, int directionY, double warpCoef)

{

	RestrictBounds(warpX, warpY, warpW, warpH);

	Mat imgCopy;

	copyMakeBorder(img, imgCopy, 0, 1, 0, 1, BORDER_REPLICATE);

	Point center(warpX + (warpW>>1), warpY + (warpH>>1));

	double radius = (warpW < warpH) ? (warpW >> 1) : (warpH >> 1);

	radius = radius * radius;

	// 平移方向矢量/模

	double transVecX = directionX - center.x;

	double transVecY = directionY - center.y;

	double transVecModel = transVecX*transVecX + transVecY*transVecY;


	// 水平/垂直增量//映射后位置与原位置

	double dx = 0, dy = 0, posX = 0.0, posY = 0.0, posU = 0.0, posV = 0.0;

	// 点到圆心距离/平移比例

	double distance = 0.0, ratio = 0.0;

	// 插值位置

	int startU = 0, startV = 0;

	double alpha = 0.0, beta = 0.0;


	int maxRow = warpY + warpH;

	int maxCol = warpX + warpW;

	uchar* pImg = NULL;

	for (int i = warpY; i < maxRow; i++)

	{

		pImg = img.data + img.step * i;

		for (int j = warpX; j < maxCol; j++)

		{

			posX = j;

			posY = i;

			dx = posX - center.x;

			dy = posY - center.y;

			distance = dx*dx + dy*dy;

			if (distance < radius)

			{

				ratio = (radius - distance) / (radius - distance + transVecModel * warpCoef);

				posU = posX - ratio * ratio * transVecX;

				posV = posY - ratio * ratio * transVecY;

 

				startU = (int)posU;

				startV = (int)posV;

				alpha = posU - startU;

				beta  = posV - startV;

				BilinearInter(imgCopy, startU, startV, alpha, beta, pImg[3*j], pImg[3*j + 1], pImg[3*j + 2]);

			}

		}

	}

}
  1.  

2013-08-05 14:46:25 iteye_10289 阅读数 160
  • Java经典算法讲解

    在面试中,算法题目是必须的,通过算法能够看出一个程序员的编程思维,考察对复杂问题的设计与分析能力,对问题的严谨性都能够体现出来。一个算法的好坏,直接影响一个方法调用的性能,进而影响软件的整体性能。算法是学习所有编程语言的基础,在Java的学习过程中首先也会选择以算法起步,本次课程重点讲解Java开发中常用的基本算法。

    29964 人正在学习 去看看 张中强

 这个算法是做图像处理的抽骨架处理(文后附抽骨架的简介),目的是求出图像的骨架,可以想象一片与物体形状相同的草,沿其外围各点同时点火。当火势向内蔓延,向前推进的火线相遇处各点的轨迹就是中轴。

该处理有很多种不同的算法,从你提供的程序来看,它属于距离矩阵的算法。它要求计算对象必须是体表示的模型(对平面来说,就是二维矩阵),通过计算每个体元素到边界的最小距离来求取模型的脊点、骨架点.

程序中freespace是输入矩阵,freespaceX和freespaceY是输入矩阵的宽和高,navi用来保存输出矩阵(既矩阵每个元素记录的是该点到达边界的最小距离。

freespace输入矩阵中,值-1代表障碍物边界,值0代表空白空间。

基本算法:

1.建立一个用矩形边界包裹freespace的新临时矩阵tmpNavi。注意,对于边界节点,其值仍然为-1,而

对于非边界节点,给予了一个固定增量(freespaceX*freespaceY*d1)。

2.用多重处理算法处理临时矩阵tmpNavi,直至tmpNavi稳定下来,不再发生改变。

3.多重处理中的每次处理的算法:遍历每个非边界节点,计算它经由它的8个相邻节点分别到达边界的距离值(既到相邻节点的距离+相邻节点自身值),取其中最小值作为它自身新值。这样周而复始,就能得到一个稳定的数值矩阵。

(程序中用了一些优化的手法,但基本的算法原理就是这样的)

4.将临时矩阵tmpNavi的内容拷贝到输出矩阵navi,并统计其中的骨点值(最大值)到m_maxValue。

希望以上回答对你有帮助。

抽骨架(Skeletonization)

    一个与细化有关的运算是抽骨架,也称为中轴变换(Medialaxis transform)或焚烧草地技术(grass-fire technigue)。中轴是所有与物体在两个或更多非邻接边界点处相切的圆心的轨迹。但抽骨架很少通过在物体内拟合圆来实现。

    概念上,中轴可设想成按如下方式形成。想象一片与物体形状相同的草,沿其外围各点同时点火。当火势向内蔓延,向前推进的火线相遇处各点的轨迹就是中轴。

      抽骨架的实现与细化相似,可采用一个两步有条件腐蚀实现,但是删除像素的规则略有不同。

    下图将细化与抽骨架进行比较。二者的主要的差别在于抽骨架在拐角处延伸到了边界,而由细化得到的骨架却没有。

上面图a是细化的效果,下面的图b是抽骨架的效果。

(左边是处理一个均匀的矩形区域,右边是处理一个均匀的圆形区域)



 

2019-10-06 23:47:00 qq_21685903 阅读数 6
  • Java经典算法讲解

    在面试中,算法题目是必须的,通过算法能够看出一个程序员的编程思维,考察对复杂问题的设计与分析能力,对问题的严谨性都能够体现出来。一个算法的好坏,直接影响一个方法调用的性能,进而影响软件的整体性能。算法是学习所有编程语言的基础,在Java的学习过程中首先也会选择以算法起步,本次课程重点讲解Java开发中常用的基本算法。

    29964 人正在学习 去看看 张中强

 Grassfire算法:

一、概念

这个算法是做图像处理抽骨架处理,目的是求出图像的骨架,可以想象一片与物体形状相同的草,沿其外围各点同时点火。当火势向内蔓延,向前推进的火线相遇处各点的轨迹就是中轴。

一个与细化有关的运算是抽骨架,也称为中轴变换(Medialaxis transform)或焚烧草地技术(grass-fire technigue)。中轴是所有与物体在两个或更多非邻接边界点处相切的圆心的轨迹。但抽骨架很少通过在物体内拟合圆来实现。
    概念上,中轴可设想成按如下方式形成。想象一片与物体形状相同的草,沿其外围各点同时点火。当火势向内蔓延,向前推进的火线相遇处各点的轨迹就是中轴。
      抽骨架的实现与细化相,可采用一个两步有条件腐蚀实现,但是删除像素的规则略有不同
    下图将细化与抽骨架进行比较。二者的主要的差别在于抽骨架在拐角处延伸到了边界,而由细化得到的骨架却没有。
上面图a是细化的效果,下面的图b是抽骨架的效果。
(左边是处理一个均匀的矩形区域,右边是处理一个均匀的圆形区域)

二、简单运算实现:(加强理解)

我们的目标是:找到start-end之间的最短路径。

如图所示。刷过leetcode的朋友看见这张应该会会心一笑,BFS,DFS这类词争先恐后往外跳。但是呢,太高级了,我的朋友们。让我们先用一种最文艺(傻气)的办法,来解决这个问题。

Grassfire 算法。小时候,大家都背过一首诗:离离原上草,一岁一枯荣。 野火烧不尽,春风吹又生。说的就是这种算法。这首诗告诉我们,草,都是从旁边的草开始燃烧蔓延的!grassfire-烧草,就这么简单又有力。

1.首先把终点的距离设定为0,然后设定距离终点最近的格子距离为1。如图所示

2.然后,距离1最近的格子是2,距离2最近的格子是3,以此类推

3.好了,这时候每一个数字都代表这该单元格到终点的距离。我们把数字连起来,就形成了最短路径,注意了,这个路径很可能不是唯一解。

整个过程用伪代码表示就是:

For each node n in the graph
2  ·n.distance=Infinity
Create an empty list.
goal.distance=0,add goal to list.
While list not empty
6  ·Let current=first node in list,remove current from list
7  ·For each node,n that is adjacent to current
8    ·If n.distance=Infinity
9      ·n.distance=current.distance+1
10      ·add n to the back of the list

 

但是有些时候,我们会遇见走不通的情况,我们写代码的时候就要考虑好这个问题

三、实现过程:
1.如果start-end之间有路,找到最短路径
2.如果start-dend之间没有路,跳出循环,报错

下面谈谈这个算法计算复杂度的问题,这个算法是一种遍历搜索,火会席卷每一个角落。

计算复杂度为:O(|V|)

其中,V是图中格子的数量。我们假设我们有100个格子,要访问的格子数
2维棋盘:100 X100 = 1000
3维棋盘: 100X100X100 = 1000000
6维棋盘: 100X100X100X100X100X100 =1000000000000

1000000000000啊朋友们,什么概念,就差不多和天上的星星一样多了哇!grassfire的计算量随着格子的变多或者维度的上升而变得很大。

好啦,总的来说这是一个很简单的算法,一定能找到全局最优解。

 

参考:1)运动规划(Motion planning)- Grassfire 算法——https://www.jianshu.com/p/e22acfc75731?from=timeline

2)grassfire算法——https://www.iteye.com/blog/benworld-1920217

2019-07-20 12:10:38 guanyumingtong 阅读数 160
  • Java经典算法讲解

    在面试中,算法题目是必须的,通过算法能够看出一个程序员的编程思维,考察对复杂问题的设计与分析能力,对问题的严谨性都能够体现出来。一个算法的好坏,直接影响一个方法调用的性能,进而影响软件的整体性能。算法是学习所有编程语言的基础,在Java的学习过程中首先也会选择以算法起步,本次课程重点讲解Java开发中常用的基本算法。

    29964 人正在学习 去看看 张中强

NXETCHIP成立于1997年,是专注于设计视频系统所需芯片企业。Nextchip将成为视频处理专营企业作为重要目标,致力于技术开发并稳步向前发展。
1998年,NEXTCHIP研发出了世界第一款支持图像分割的Video Controller,并成功进军视频安防市场。Nextchip是国内最早成功开发以及量产DVR视频解码器以及CCTV ISP的企业,这也为公司的成长奠定了基础。在此之后,通过不断的技术创新和市场开拓,保证了公司的持续成长。
Nextchip是目前世界上唯一一家拥有适用于CCTV和DVR的核心图像处理系统半导体Full Line-up的企业,并在视频安防市场技术上领先。从2011年开始,公司将从视频安防市场上积累的图像处理半导体技术,应用于开发Automotive camera市场所需的产品上,并希望通过新产品的推出,实现崭新的飞跃。
Nextchip承诺,每个员工团结一致,为了世界和人类的发展,不断挑战、贡献,从而创造崭新的未来。开发创造出为我们及子孙后代的生活所需、技术与产品是NEXTCHIP的规划以及坚定的理念。 并以这样的哲学为基础,开发出客户和市场所需要的技术。以正确的企业精神,通过实践透明化经营理念提升企业价值,回报长期以来对我们信任和支持的人们。
产品主要包括:ISP、AHD、SOC、ADAS
ISP
汽车 ISP :NVP2631、NVP2650 、NVP2630、NVP2630I、NVS2700 、NVS2710…
AHD
模拟编码 (Encoder TX) : NVP6021 …
模拟解码 (Decoder RX) : NVP6124、NVP6158C、NVP6321、NVP6324 …
ADAS
APACHE4 Nextchip,体验无限可见性…
软件算法是VADAS公司研发的,精彩的效果吸引着各大车厂,Tier1公司,目前已经在多种车型中得到应用。
在这里插入图片描述

2006-10-28 12:42:00 Suprman 阅读数 3521
  • Java经典算法讲解

    在面试中,算法题目是必须的,通过算法能够看出一个程序员的编程思维,考察对复杂问题的设计与分析能力,对问题的严谨性都能够体现出来。一个算法的好坏,直接影响一个方法调用的性能,进而影响软件的整体性能。算法是学习所有编程语言的基础,在Java的学习过程中首先也会选择以算法起步,本次课程重点讲解Java开发中常用的基本算法。

    29964 人正在学习 去看看 张中强

从数字图像处理的基本理论,我们可以知道:图像的变形变换就是源图像到目标图像的坐标变换。简单的想法就是把源图像的每个点坐标通过变形运算转为目标图像的相应点的新坐标,但是这样会导致一个问题就是目标点的坐标通常不会是整数,而且像放大操作会导致目标图像中没有被源图像的点映射到,这是所谓“向前映射”方法的缺点。所以一般都是采用“逆向映射”法。
但是逆向映射法同样会出现映射到源图像坐标时不是整数的问题。这里就需要“重采样滤波器”。这个术语看起来很专业,其实不过是因为它借用了电子信号处理中的惯用说法(在大多数情况下,它的功能类似于电子信号处理中的带通滤波器),理解起来也不复杂,就是如何确定这个非整数坐标处的点应该是什么颜色的问题。前面说到的三种方法:最近邻域法,线性插值法和三次样条法都是所谓的“重采样滤波器”。
所谓“最近邻域法”就是把这个非整数坐标作一个四舍五入,取最近的整数点坐标处的点的颜色。而“线性插值法”就是根据周围最接近的几个点(对于平面图像来说,共有四点)的颜色作线性插值计算(对于平面图像来说就是二维线性插值)来估计这点的颜色,在大多数情况下,它的准确度要高于最近邻域法,当然效果也要好得多,最明显的就是在放大时,图像边缘的锯齿比最近邻域法小非常多。当然它同时还带业个问题:就是图像会显得比较柔和。这个滤波器用专业术语来说(呵呵,卖弄一下偶的专业^_^)叫做:带阻性能好,但有带通损失,通带曲线的矩形系数不高。至于三次样条法我就不说了,复杂了一点,可自行参考数字图像处理方面的专业书籍,如本文的参考文献。
再来讨论一下坐标变换的算法。简单的空间变换可以用一个变换矩阵来表示:
[x’,y’,w’]=[u,v,w]*T
其中:x’,y’为目标图像坐标,u,v为源图像坐标,w,w’称为齐次坐标,通常设为1,T为一个3X3的变换矩阵。
这种表示方法虽然很数学化,但是用这种形式可以很方便地表示多种不同的变换,如平移,旋转,缩放等。对于缩放来说,相当于:
                         [Su 0 0 ]
[x, y, 1] = [u, v, 1] * | 0 Sv 0 |
                         [0 0 1 ]
            
其中Su,Sv分别是X轴方向和Y轴方向上的缩放率,大于1时放大,大于0小于1时缩小,小于0时反转。
矩阵是不是看上去比较晕?其实把上式按矩阵乘法展开就是:
{ x = u * Su
{ y = v * Sv
就这么简单。^_^
有了上面三个方面的准备,就可以开始编写代码实现了。思路很简单:首先用两重循环遍历目标图像的每个点坐标,通过上面的变换式(注意:因为是用逆向映射,相应的变换式应该是:u = x / Su 和v = y / Sv)取得源坐标。因为源坐标不是整数坐标,需要进行二维线性插值运算:
P = n*b*PA + n * ( 1 – b )*PB + ( 1 – n ) * b * PC + ( 1 – n ) * ( 1 – b ) * PD
其中:n为v(映射后相应点在源图像中的Y轴坐标,一般不是整数)下面最接近的行的Y轴坐标与v的差;同样b也类似,不过它是X轴坐标。PA-PD分别是(u,v)点周围最接近的四个(左上,右上,左下,右下)源图像点的颜色(用TCanvas的Pixels属性)。P为(u,v)点的插值颜色,即(x,y)点的近似颜色。
这段代码我就不写的,因为它的效率实在太低:要对目标图像的每一个点的RGB进行上面那一串复杂的浮点运算。所以一定要进行优化。对于VCL应用来说,有个比较简单的优化方法就是用TBitmap的ScanLine属性,按行进行处理,可以避免Pixels的像素级操作,对性能可以有很大的改善。这已经是算是用VCL进行图像处理的基本优化常识了。不过这个方法并不总是管用的,比如作图像旋转的时候,这时需要更多的技巧。
无论如何,浮点运算的开销都是比整数大很多的,这个也是一定要优化掉的。从上面可以看出,浮点数是在变换时引入的,而变换参数Su,Sv通常就是浮点数,所以就从它下手优化。一般来说,Su,Sv可以表示成分数的形式:
Su = ( double )Dw / Sw; Sv = ( double )Dh / Sh
其中Dw, Dh为目标图像的宽度和高度,Sw, Sh为源图像的宽度和高度(因为都是整数,为求得浮点结果,需要进行类型转换)。
将新的Su, Sv代入前面的变换公式和插值公式,可以导出新的插值公式:
因为:
b = 1 – x * Sw % Dw / ( double )Dw; n = 1 – y * Sh % Dh / ( double )Dh
设:
B = Dw – x * Sw % Dw; N = Dh – y * Sh % Dh
则:
b = B / ( double )Dw; n = N / ( double )Dh
用整数的B,N代替浮点的b, n,转换插值公式:
P = ( B * N * ( PA – PB – PC + PD ) + Dw * N * PB + DH * B * PC + ( Dw * Dh – Dh * B – Dw * N ) * PD ) / ( double )( Dw * Dh )
这里最终结果P是浮点数,对其四舍五入即可得到结果。为完全消除浮点数,可以用这样的方法进行四舍五入:
P = ( B * N … * PD + Dw * Dh / 2 ) / ( Dw * Dh )
这样,P就直接是四舍五入后的整数值,全部的计算都是整数运算了。
简单优化后的代码如下:
int __fastcall TResizeDlg::Stretch_Linear(Graphics::TBitmap * aDest, Graphics::TBitmap * aSrc)
{
    int sw = aSrc->Width - 1, sh = aSrc->Height - 1, dw = aDest->Width - 1, dh = aDest->Height - 1;
    int B, N, x, y;
    int nPixelSize = GetPixelSize( aDest->PixelFormat );
    BYTE * pLinePrev, *pLineNext;
    BYTE * pDest;
    BYTE * pA, *pB, *pC, *pD;
    for ( int i = 0; i <= dh; ++i )
    {
        pDest = ( BYTE * )aDest->ScanLine[i];
        y = i * sh / dh;
        N = dh - i * sh % dh;
        pLinePrev = ( BYTE * )aSrc->ScanLine[y++];
        pLineNext = ( N == dh ) ? pLinePrev : ( BYTE * )aSrc->ScanLine[y];
        for ( int j = 0; j <= dw; ++j )
        {
            x = j * sw / dw * nPixelSize;
            B = dw - j * sw % dw;
            pA = pLinePrev + x;
            pB = pA + nPixelSize;
            pC = pLineNext + x;
            pD = pC + nPixelSize;
            if ( B == dw )
            {
                pB = pA;
                pD = pC;
            }
            for ( int k = 0; k < nPixelSize; ++k )
                *pDest++ = ( BYTE )( int )(
                    ( B * N * ( *pA++ - *pB - *pC + *pD ) + dw * N * *pB++
                    + dh * B * *pC++ + ( dw * dh - dh * B - dw * N ) * *pD++
                    + dw * dh / 2 ) / ( dw * dh )
                );
        }
    }
    return 0;
}
应该说还是比较简洁的。因为宽度高度都是从0开始算,所以要减一,GetPixelSize是根据PixelFormat属性来判断每个像素有多少字节,此代码只支持24或32位色的情况(对于15或16位色需要按位拆开—因为不拆开的话会在计算中出现不期望的进位或借位,导致图像颜色混乱—处理较麻烦;对于8位及8位以下索引色需要查调色板,并且需要重索引,也很麻烦,所以都不支持;但8位灰度图像可以支持)。另外代码中加入一些在图像边缘时防止访问越界的代码。
通过比较,在PIII-733的机器上,目标图像小于1024x768的情况下,基本感觉不出速度比StretchDraw有明显的慢(用浮点时感觉比较明显)。效果也相当令人满意,不论是缩小还是放大,图像质量比StretchDraw方法有明显提高。
不过由于采用了整数运算,有一个问题必须加以重视,那就是溢出的问题:由于式中的分母是dw * dh,而结果应该是一个Byte即8位二进制数,有符号整数最大可表示31位二进制数,所以dw * dh的值不能超过23位二进制数,即按2:1的宽高比计算目标图像分辨率不能超过4096*2048。当然这个也是可以通过用无符号数(可以增加一位)及降低计算精度等方法来实现扩展的,有兴趣的朋友可以自己试试。
 from http://00000000.net.cn/Index.htm

其他文档:

aspjpeg组件高级使用方法介绍 

解密:一张所有XP用户都感到吃惊的图片 

JPEG简易文档 

BMP位图文件结构及VC操作 

一个图形界面的俄罗斯方快c源码 

AutoCad二次开发:ObjectARX技术谈  

<script type="text/javascript" src="http://pagead2.googlesyndication.com/pagead/show_ads.js"> </script>
没有更多推荐了,返回首页