keep it simple

2011-10-11T21:12:00.001+08:00

有一个难题，例如一个大的三角形里面随便画几个stroke，可能是相交的，怎么根据strokes来对这个三角形做三角剖分，得到的还是三角形，不包含多边形。

想一个算法来解决问题的过程（这些问题不是text book上有标准answer的）：先想/实现一个简单的情况，例如都没有相交(怎么判断相交?), 然后假如有某种相交，在原来实现的算法上加入一些cases，然后假如还有某种复杂的情况，在原来实现的算法上在加入一些cases.... (没有想到的某些情况，就留到bug了)....

1. 是一个渐进的过程。

2. 别老是想重写。

假如在假如某些cases or 想着想着想要重写，多半不是good idea，因为很可能重写之后包含了新的cases但遗漏了旧的cases.

假如在过了一段时间回来这codes fix bugs时候，想要重写，多半不是good idea，因为很可能连当初为什么那样写都想不清楚or想不齐所有旧的cases.

2011-08-29T15:15:00.002+08:00

怎么定义一个QuadTriMesh, 同时支持quad and triangle faces?

class QuadTriMesh : public BaseMesh {

public:

struct Face;

...

};

#define NIL uint(~0)

struct QuadTriMesh::Face {

unsigned int id;

unsigned int v[4];

bool isQuadFace() const { return v[3] != NIL; };

};

2011-08-23T18:45:00.001+08:00

- 养成习惯工作在早上就开始做，别看看新闻推到下午or晚上。

- 修改某mesh operation的错误时候最难最怕就是等为出错在哪些face/vertex/edge, 如果能在maya中建一些简单的模型来重现, 这就好办了。

- 不想改变的变量加const.

- 考虑函数里的指针加QScopedPointer<T> ...

- C++ Destructor: 1. 子类的destructor总会自动调用父类的destructor吗?

2. destructor里面除了需要delete pointers之外其它的变量呢?

- http://www.mikeash.com/pyblog/friday-qa-2011-01-04-practical-floating-point.html

http://altdevblogaday.com/2011/08/21/practical-flt-point-tricks/?utm_source=twitterfeed&utm_medium=twitter

-what is LLVM ?

- http://code.google.com/p/alembic/

http://www.cgsociety.org/index.php/CGSFeatures/siggraph2011#alembic_1.0

- OpenColorIO (OCIO) is a new open source project from Sony Pictures Imageworks (SPI), which they hope will soon be widely adopted across the Industry. SPI – it must be said, especially since Rod Bredow took the role of CTO, – has excelled at meeting the open source community head on and spearheading along with ILM (and their OpenEXR work) – some of the most impressive displays of industry co-operation we have seen in years, if not decades.

- http://advances.realtimerendering.com/s2011/ Advances in Real-Time Rendering in 3D Graphics and Games.

http://iryoku.com/aacourse/ ACM SIGGRAPH 2011 Course Filtering Approaches for Real-Time Anti-Aliasing

- http://fgiesen.wordpress.com/ A trip through the Graphics Pipeline 2011.

- John Carmack (ID_AA_Carmack) on Twitter: Reading "Infrastructure: the book of everything for the industrial landscape". Much respect to civil engineers!

2011-08-16T12:07:00.001+08:00

- "Low-pass filtering statistics",

- Eigen library (http://eigen.tuxfamily.org)

Eigen's Geometry module provides two different kinds of geometric transformations:

1. Abstract transformations, such as rotations (represented by angle and axis or by a quaternion), translations, scalings. These transformations are NOT represented as matrices, but you can nevertheless mix them with matrices and vectors in expressions, and convert them to matrices if you wish. 这种类型描述的都是Pure R/T/S.

2. Projective or affine transformation matrices 两种: see the Transform class. These are really matrices. 其实是Represents an homogeneous transformation in a N dimensional space.

例如这是一个affine transformation matrix的例子, 描述的是concatenation_of_any_transformations: Transform<float,3,Affine> t = Translation3f(p) * AngleAxisf(a,axis) * Scaling3f(s);

An affine transformation matrix M is shaped like this:

( linear translation )

( 0...0 1 ) // the last row can be assumed to be [0...0 1]

Note that for a projective transformation the last row can be anything, and then the interpretation of different parts might be sightly different.

Isometry if the transformation is only a concatenations of translations and rotations. (In Euclidean geometry, a rotation is an example of an isometry, a transformation that moves points without changing the distances between them. from wikipedia)

Transformation Types:

2D rotation from angle Rotation2D

3D rotation as an angle + normalized axis AngleAxis

"Finally Rotation2D and AngleAxis are mainly convenient types to create other rotation objects." These are two most simplest rotation types.

- 遇到一个bug. QA用的版本可以稳定重新，但是我就是不能重现，所以我怀疑daily build是不是包含了最新的code. 后来试了最近的check in也包含在daily build里面, 应该就不是没有包含最新code了。同事建议看看release 和 debug版本。果然release version可以重新 debug版本不可以重新. 一直跟踪发现原因一个数组值没有初始化, 在debug中被初始化为3452816845 也就是0xcdcdcdcd, 但在release下大部分是0.

- NVIDIA path render,

- 工作需要了解求Normal Map细节，于是读了NVIDIA mesh tool(http://code.google.com/p/nvidia-mesh-tools/)中NVMeshMender的实现, 知道了Tangent space的求法, 例如先根据uv求出TB然后假如N的时候考虑smoothgroup. NVIDIA的工具Melody虽然没有给出代码实现, 但可以玩玩normal map的生成.

- "State of the Art Report, Survey of Real-Time Tessellation & Geometry Synthesis Methods" 罗列了相关papers.

- http://www.lysator.liu.se/c/c-faq/c-1.html C-FAQ.

- Check the QScopedPointer for resource acquisition is initialization(RAII), and QSharedPointer for reference count.

代码bug

2011-08-12T10:28:00.001+08:00

昨天写代码犯了个错误：

子类override父类的virtual member function时候不需要写函数参数的default values。

顶点边面数目的关系

2011-07-29T16:23:00.002+08:00

今天看模型时候观察到了一个规律，原来这个规律还有理论支持。

三角面local frame上的tangent

2011-07-28T20:50:00.000+08:00

两个向量的夹角

2011-07-28T20:49:00.000+08:00

不同local frame之间的角度值

2011-07-25T11:56:00.000+08:00

weekly update

2011-07-25T10:13:00.001+08:00

- row-major vs. column-major, affine transform. some history, http://fgiesen.wordpress.com/2011/05/04/row-major-vs-column-major-and-gl-es .

- a trip through the graphics pipeline 2011, http://fgiesen.wordpress.com/2011/07/09/a-trip-through-the-graphics-pipeline-2011-index/

- "Obligatory FXAA Post", what is AA/MSAA/MLAA (doing AA as a post-process, depth based)/FXAA (post-process, luminosity based technique)? 例如对FXAA最好的理解是你之前尝试过了其他AA方法并知道有什么问题然后去看新技术是否克服了旧问题;// "Image Space for Beginners" Render a Quad with the texture you want to do sth on, shader code. A distortion example with code.// "Moving beyond the Linear Bezier" linear, quadratic and bezier curve equations. level of continuity C0/C1/..., how to obtain a piecewise bezier with C1 continuity(meaning that the first derivative is continuously defined), how to obtain a cubic beizer curve that has C2 continuity with deBoor points.// "Little more theory with your mesh", Euler Characteristic, Closure/Link/Star of simplicial complex. http://jonmanatee.blogspot.com/

- book [A New Kind Of Science by Stephen Wolfram, 2002].

- [Procedural Textures Mapping using Geodesic Distance 2011]

- from twitter, ID_AA_Carmack John Carmack "I would like to use reference and const object fields more, but it can require awkward dances in initialization lists." 复习了有两种东西需要在初始化列表中完成初始化的.

三角形法向 - 两个frame之间的angle

2011-07-25T10:11:00.002+08:00

叉积的方向

2011-07-20T17:24:00.000+08:00

weekly update

2011-07-16T14:53:00.002+08:00

- What is the OpenGL Context look like? A structure in C? An object is attached to a target (a pointer in C), then the state machine use the target to get and set the value of the object? http://www.arcsynthesis.org/gltut/Basics/Intro%20What%20is%20OpenGL.html

- profiling. Mac上的shark比较流行，可惜在windows上没有.

Download Windows SDK, v7.1, to get the xperf application and play with it.

xperf http://msdn.microsoft.com/en-us/performance/cc825801.aspx and Process Explorer.

Debugging Tools for Windows (x64)

Microsoft Windows Performance Toolkit

Microsoft Windows SDK v7.1

a similar profiler from AMD http://developer.amd.com/tools/CodeAnalyst/Pages/default.aspx

- 继续看[Introduction to Linear Algebra]里面的subspace, column space, null space的概念。

Column space contains all the right hand sides, in which case the Ax = b is solvable. The Null space N(A) contains all the solutions of Ax = 0.

- 继续读[Scientific Computing: An Introductory Survey by Michael Heath]

1. 在书中解nonlinear equations system or optimization的例子时候终于知道跟linear system ( system of linear equations )的关系了, 用iterative methods解前者的问题时候每一步都迭代中很可能需要解一个线性方程组来得到下一步走向的信息. 例如在P158 5.2.3, Newton's Method for One dimension nonlinear equation: use a linear line to fit the curve at every step.

2. 怎么求解minimization of quadratic function/energy (which is quadratic object function without constraints)?, for example min||Bx - b||^2 -> f(x) = x^t*B^t*B*x - B^t*b*x -> A = B^t * B, a = B^t * b,

Ax=b, which A is spd, can be solved by conjugate gradient method.

2011-06-28T14:14:00.004+08:00

random number

--------- Possion disk sampling.

--------- Perlin Noise

http://devmag.org.za/2009/05/03/poisson-disk-sampling/

http://devmag.org.za/2009/04/25/perlin-noise/

http://devmag.org.za/2011/06/25/implementing-and-debugging-the-perlin-noise-algorithm/

Bezier curves

http://devmag.org.za/2011/04/05/bzier-curves-a-tutorial/

http://devmag.org.za/2011/06/23/bzier-path-algorithms/

近来遇到的问题是怎么求underdetermined systems, 以及minimize a quadratic energy, 我还是好像system of equation 跟 optimization是怎么联系在一起的.

Graphics memory size

2011-06-25T18:38:00.006+08:00

Sometimes, you may need to how many memory left, we can use the GL_NVX_gpu_memory_info, the code snippet comes from the reference.

#define GL_GPU_MEM_INFO_TOTAL_AVAILABLE_MEM_NVX 0x9048
#define GL_GPU_MEM_INFO_CURRENT_AVAILABLE_MEM_NVX 0x9049
   GLint total_mem_kb = 0;
   glGetIntegerv(GL_GPU_MEM_INFO_TOTAL_AVAILABLE_MEM_NVX, &total_mem_kb);
   GLint cur_avail_mem_kb = 0;
   glGetIntegerv(GL_GPU_MEM_INFO_CURRENT_AVAILABLE_MEM_NVX,&cur_avail_mem_kb);
   fprintf(stderr, "NV totoal mem %ikb, avail mem %ikb, used %ikb.\n", total_mem_kb, cur_avail_mem_kb, (total_mem_kb - cur_avail_mem_kb));

reference:

http://www.geeks3d.com/20100531/programming-tips-how-to-know-the-graphics-memory-size-and-usage-in-opengl/

http://www.tohtml.com/cpp/

http://codeformatter.blogspot.com/2009/06/about-code-formatter.html

2011-04-18T10:10:00.003+08:00

Better Explained (learn right, not note)

Vector Calculus: Understanding Gradient, Divergence, Flux, Circulation and Curl.

Multivariable calculus and vector analysis (a set of on-line readings), by math.umn.edu/

Discrete Differential Geometry : Theory and Practice. by cs.caltech.edu/

Tech Coord

2011-04-07T10:27:00.003+08:00

2011-02-01T10:31:00.001+08:00

阅读笔记

Using hardware acceleration for graphics, on March 13, 2009

Question 1: 给hardware分类.

标准一: 是UnifiedMemoryArchitecture(UMA), 还是Dedicated graphics memoery(Non-UMA) ?

标准二: 根据graphics operations来分five categories.

于是一共十种类型types.

我们在PC上常见的都是Non-UMA + programmable-3D的.

Question 2: How can Qt off-load graphics operations to these different types of hardware?

不同的hardware type有不同的rendering back end(QPaintEngine的具体实现):

Qt \ / QPaintEngine for type X:

| -- QPainter --| QPaintEngine for type Y:

Application / \ QPaintEngine for type Z:

Type UMA Non-UMA

None Raster Raster*

Blitter DirectFB DirectFB**

2D vector OpenVG*** OpenVG***

Fixed-3D OpenGL (ES) 1.x OpenGL (ES) 1.x

Programmable-3D OpenGL (ES) 2.x OpenGL (ES) 2.x****

* When using raster on NUMA, rendering is actually done in system memory first, then flushed to VRAM

** This is the one which is going to be slow when doing anything other than QPainter::drawPixmap()

*** It shouldn’t be a big surprise we’re researching an OpenVG paint engine!

**** Qt 4.5 contains a new paint engine for OpenGL ES 2.x which we’re now making work on desktop OpenGL 2.0.

Qt Graphics and Performance – An Overview, on December 16, 2009

关于QWidget and QWindowSurface:

关于Graphics systems:

You can select graphics systems either by starting the application with the command line option -graphicssystem raster|opengl|opengl1|x11|native, where “native” means to use the system default. Another option is to provide the exact same option to configure which will set that option for all applications using Qt. Finally there is the function QApplication::setGraphicsSystem which hardcodes the graphics system for a given application.

关于Images and Pixmaps:

The difference between these two is mostly covered in the documentation, but I would like to highlight a few things none the less.

Our documentation says: “QImage is designed and optimized for I/O, and for direct pixel access and manipulation, while QPixmap is designed and optimized for showing images on screen.”

这有点像Image跟Texture的区别, 后者可能是前者的封装加上一个OpenGL texture ID以便render.

Qt Graphics and Performance – OpenGL, on January 6, 2010

什么是OpenGL, 为什么选择OpenGL ES 2.0?

QPainter将东西传给OpenGL来画, GL paint engine turn the whole of the QPainter API into "just a bouch of triangles". 举了一个例子说明.

Interleaved Rendering：

void widget::paintEvent(QPaintEvent *)

{

QPainter .... // 不同的painter来画.

QPainter .... //

}

Mixing QPainter and Native OpenGL

QGLWidget vs OpenGL Graphics-System

我看懂了OpenGL paint engine, 但是不懂OpenGL Graphics-System是什么概念, 为什么跟QGLWidget来比较, 后者全部东西都是用OpenGL paint engine来画, "all use the OpenGL paint engine regardless of what graphics system is being used. QGLWidget is basically a regular widget which always has a native window ID and is always rendered to using OpenGL. You are free to choose whichever method you want to get OpenGL rendering (graphics system or QGLWidget). However, using the opengl graphics system can often be slower than using a QGLWidget". 是说我们App中可以选择用QGLWidget或者OpenGL graphics system?

QGLWidget的缺点是不能局部sub-area更新, 需要重画整个widget.

2011-01-23T17:05:00.004+08:00

有些图案是artist随性的创作，有些是规律的，当中有对称的有pattern的，前者我做不了啦，后者倒是可以学学。
下面是这两天收集的blogs.

------
http://www.subblue.com/blog 上面很多用Pixel Bender做的fractal的效果, 他甚至"The images were rendered using a new fractal renderer I'm working on in Pixel Bender. I'll be releasing it once I'm happy with the final script."
然后好奇地查了一下:

Adobe Pixel Bender Tookit 我理解为是Image Processing工具.
Adobe Pixel Bender is a programming language that is used to create or manipulate image content. Using Pixel Bender you create a kernel, also known in this document as a shader. The shader defines a single function that executes on each of the pixels of an image individually.
In Flash Player and Adobe AIR, three types of effects can be easily created using a shader: drawing fill, blend mode, filter.
Note: Pixel Bender support is available starting in Flash Player 10 and Adobe AIR 1.5.

ActionScript is the programming language for the Adobe Flash Player and Adobe AIR run-time environments. It enables interactivity, data handling, and much more in Flash, Flex, and AIR content and applications.

他多次提到用了这里的技术http://iquilezles.org/www/, http://iquilezles.org/www/articles/mandelbulb/mandelbulb.htm, http://iquilezles.org/www/articles/ssao/ssao.htm, 原来还有http://iquilezles.org/prods/index.htm

还提到一个不错的forum, http://www.fractalforums.com/3d-fractal-generation/true-3d-mandlebrot-type-fractal.
-----------------
另一blog
http://blog.hvidtfeldts.net/index.php/2007/05/
他的作品http://structuresynth.sourceforge.net/ Structure Synth is a cross-platform application for generating 3D structures by specifying a design grammar. Even simple systems may generate surprising and complex structures. The design grammar approach was originally devised by Chris Coyne (for a 2D implementation see the popular Context Free Art).
用语法grammar生成模型结构.
http://www.contextfreeart.org/ Context Free is a program that generates images from written instructions called a grammar. The program follows the instructions in a few seconds to create images that can contain millions of shapes.

Context Free提到了用Anti-Grain Geometry(AGG)来做底层的2D graphics library. 原来AGG是很有名的2D rendering engine http://www.antigrain.com/about/index.html，Qt的2D Raster Engine在实现时候也考虑过AGG(http://labs.qt.nokia.com/2009/12/18/qt-graphics-and-performance-the-raster-engine/). AGG只是software rendering, 没有用到GL-based acceleration.

Cairo is a 2D graphics library with support for multiple output devices (貌似也叫back ends). Currently supported output targets include the X Window System, Quartz, Win32, image buffers, PostScript, PDF, and SVG file output. Experimental backends include OpenGL, XCB, BeOS, OS/2, and DirectFB, 还有Qt等.

Skia is a complete 2D graphic library for drawing Text, Geometries, and Images. 3x3 matrices w/ perspective;antialiasing, transparency, filters;shaders, xfermodes, maskfilters, patheffects.
New backend for GPUs: There is a new library, sitting along side skia. Next to src/ and include/ is gpu/. This stand-along library is an abstraction for drawing 2D primitives to a GPU. GrContext.h is the header you should read first. Skia can use this to redirect 100% of its drawing to the GPU, via subclasses in src/gpu. SkGpuCanvas and SkGpuDevice.
------
http://processing.org/ 貌似是一种很popular的create images, animations, and interactions的open source programming language. 是基于Java的，文档倒是很清晰.
还有几本本评价很高books，其一是:
Processing: A Programming Handbook for Visual Designers and Artists [Hardcover].

------
先学习一些math and formula, 生成一些经典的shape and fractal, 2D的话考虑用AGG/Cairo/Skia/Qt等来render比较方便, 3D的话当然需要用OpenGL来render.

2011-01-21T18:14:00.007+08:00

the main theme of this stage is bug fixing for me, but still sth can be learned from:

其中左边是一个(0,0) to (1,1)的方形square, 右边是一个(1,0) to (2,1)的方形square, 怎么判断三角形是在其中一个square里面，而不是跨过了两个squares呢，像那个红色的三角形? 运行三角形triangle刚好接触到两边界, 如那个大的green三角形.

下面只看横方向的坐标，纵向的Yaxis也类似：

bool isCrossSquare = (int)start.x != (int)end.x; 错的. 因为int是四舍五入, int(-0.2) = 0. bool isCrossSquare = floor(start.x) != floor(end.x); 对的.

当然还得考虑特殊情况，像上面的大绿色三角形:

floor(start.x) = 0, floor(end.x) = 1, 但end.x == floor(end.x)表示右边压界，所以例外。

还得考虑横跨了两个square并刚好压界.

完整的判断是:

bool isCrossSquare = (floor(start.x) != floor(end.x) && end.x != floor(end.x)) || (end.x - start.x > 1);

其中一个应用实例是判断uv layout有没有超出范围.

2011-01-20T21:26:00.007+08:00

今天有看到box filter这名词了, ptex的paper中提到用box filter做symmetric reductions of each texture(also use asymmetric reduction for anisotropic filtering), 于是又想回顾一下这些概念.

什么是filter (filter kernel)? hint: a pattern.

什么是convolution? 什么是image filtering?

Box filter这里的box好像是指这个filter的形状shape, 例如3*3, 而像Bicubic filter这filter的shape在一维来看是曲线，二维来看估计是圆形. (可能用box filter来跟bicubic filter来做比较不是十分合适，我的理解中box filter好像是指一类filter，只要它们的shape都是rectangle, 而bicubic filter好像是特地的一种, 但又可能不是，因为bicubic函数系数不一样得到的curve是不一样的？)

Box filter是系数都是positive, 于是起到的是模糊smooth的效果，而Bicubic filter的系数weight中山有negative的，于是能起到a slight sharpening effect.

在GPU中实现时候为了避免bicubic的计算，可以用look-up table的方法(在CPU中建float-precision texture). 具体看[1].

Reference:

[1] High-Quality Filtering http://http.developer.nvidia.com/GPUGems/gpugems_ch24.html

下面是对box filter和bilinear filter的感性区别, box filter是求中间11号texel时候用包括自身在内的9个texel做平均(也可以理解为系数固定的线插interpolation)，而bilinear filter是图片放大or缩小or大小不变但是错位时候求自身texel时候对最近的4个做线插, 线插的系数跟自身texel离那4个texels的距离有关, bilinear filter常见于OpenGL (or GPU hardware) interpolation(texture filtering), 例如在magnification情况下一个texel占了多个pixels, 那每一pixel的color就找最近的4个Texels用bilinear interpolation，这类似于把image缩小，小的image的一个texel相当于在大的image的多个texel的线插.

2011-01-18T20:22:00.001+08:00

Motorcycle Graphs: Canonical Quad Mesh Partitioning.(摩托车图: 标准的四边形网格剖分:-)
A mesh is structured if it has no extraordinary vertices, and unstructured otherwise. The main subjects of this paper are structured partitions in which the quadrilaterals of a mesh (semi-regular mesh) are partitioned into a small number of structured submeshes.

Extraordinary vertices都是作为分界点, 假如user先选择两个extraordinary vertices然后连在一起，是不是会加快计算呢?

2011-01-18T15:37:00.004+08:00

These are examples and resources about renderer:

Ray Tracing:

YafaRay: .

LuxRender: original based on PBRT in 2007.

Physically Based Rendering, Second Edition: From Theory To Implementation by Matt Pharr.

Ray Tracing from the Ground Up by Kevin Suffern.

RenderMan compliant renderers:

Pixar RenderMan(PRman): RiSpec, the RenderMan Interface Specification. It is built around the REYES algorithm. The popular shading language is RSL developed by Pixar. OSL released by Sony is another story(check the OpenImageIO too).

Aqsis: Open source 3D solution adhering to the RenderMan interface standard by Pixar Animation Studios.

Pixie, a bit like a dead project since 2005.

3Delight, 6 months of free license.

From this pic, RenderMan is just an API to communicate with renderers(RenderMan is not a renderer, it is an interface description. But often renderman is used as a synonym for the render PRman itself). There are two main parts of RenderMan: 3D scene description language(.rib, RenderMan Interface Bytestream), and Programable shading language(.sl). Introduction to PRman.

2011-01-17T21:00:00.002+08:00

These are some of the papers and resources related to virtual texturing:

http://anteru.net/2008/07/25/242/

http://www.pcper.com/article.php?aid=532&type=overview

http://en.wikipedia.org/wiki/MegaTexture

还有GigaVoxel

GigaVoxels : Ray-Guided Streaming for Efficient and Detailed Voxel Rendering

Beyond Triangles : GigaVoxels Effects In Video Games

http://www.icare3d.org 相关的东西。

google: a sparse voxel octree data structure

http://www.tomshardware.com/reviews/voxel-ray-casting,2423-5.html The advantage of sparse voxel octrees.

http://raytracey.blogspot.com/2008/08/voxel-ray-tracing-vs-polygon-ray.html

Efficient sparse voxel octrees, NVIDA在google code上提供cuda实现.

Andreas Neu, Bachelor Thesis, Virtual Texturing, April 2010;

Albert Julian Mayer, Vertual Texturing, http://www.cg.tuwien.ac.at/research/publications/2010/Mayer-2010-VT/Mayer-2010-VT-Paper.pdf;

2010-12-29T17:57:00.002+08:00

突然觉得计划生育的原因，害得没有了所谓的家族几代的概念（可能我太传统了，觉得家族的延伸需要男ding）。那一个家庭的生意和事业怎么延伸呢?

A家的事业，传给了C，C是A的女人or外孙，C是B家的媳妇or孙子，那往后的事业不就成了B家的吗？

2010-12-29T11:18:00.004+08:00

吴军的浪潮之巅 - Intel

2011/1/7 update 近来看到news说Microsoft的windows做ARM cpu的版本了。查了一下ARM，原来可以理解为一个公司名or一种CPU架构，于是CPU的架构包括了intel's x86, ARM, IBM's POWER(PowerPC缘由POWER体系架构)等. 其中ARM和Power都是RISC的，而Linux支持CISC和RISC指令集。

于是来了一个问题，OS是怎么支持某种指令集的呢？

OS or other program -> compile to be object file-> link to be execution.

Compile的过程在预编译词法语法分析得到汇编时候就考虑RISC/CISC?

还是汇编代码-->机器指令这这时候才考虑RISC/CISC?

reference:

[1]

[2] http://www.ibm.com/developerworks/cn/linux/l-powhist/ 人类的POWER IBM芯片制造史

Weekly update 2010/9/6~

2010-09-13T09:36:00.000+08:00

http://en.wikipedia.org/wiki/HSL_and_HSV
http://www.manifold.net/doc/colors_as_hue_saturation_and_brightness.htm

讲述GUI的history，也是发展了2/30年嘛. keyword: xerox, windows, mac.
http://www.gladdengraphics.com/academics/GradCourses/ComputerGraphicsHistory/ResearchPaper/parcgui01.pdf

There is a case that pointer is needed. for example,
class GLSLShaderProgram {
public:
GLSLShaderProgram *createInstanceFromSource(vs string, fs string);
protected:
GLSLShaderProgram(...);
...
};
In this case, we cannot define something like this:
class App {
public:
App(): ... {}
private:
GLSLShaderProgram m_programHandle;
};
Because the m_programHandle will be initialized in the initialization list with constructor, which is not available from outside.

后来我才意识到:
shading effect = lighting + material of geometry.
而shading shader 就是那个”+”加号, 根据特定的shading stype来计算.
所以GLSLShadingProgram不该直接放到App里面, 而是例如:
而且具体的某一个shading shader 就是用于某一种shading effect的.
class App {
PhongShading m_phong;
};
class PhongShading {

bool initialize() {

m_programHandle = createProgramFromFile(phong.glsl);

return m_programHandle != 0;

}

GLSLShadingProgram m_programHandle;
};
class Model {
void render() {
get m_phong from app;
set the lighting and material parameters;
active the shading program to draw the model;
};

How the mask is effecting on a image layer?
Blend mode 用于有一个background image, 当上面加一个image做blending and composing时候用的。
Masks是附加于a specified image layer, 不修改影响那个image layer本身(un-destructive), 只是觉得那些pixel可以透过mask被看到, 那些被遮挡了不能看到.
Shader中是怎么实现的呢?

What is the l-value and r-value, difference?
http://blogs.msdn.com/b/vcblog/archive/2009/02/03/rvalue-references-c-0x-features-in-vc10-part-2.aspx

Weekly update 2010/8/23-29

2010-08-31T21:52:00.003+08:00

跟UI打交道的一周.

Qt Model/View architecture:
Model: QModelIndex, internalPainter is used to associate the custom item pointer to the QModelIndex, the custom item class is defined by us and is used to store the custom data.
View: there are mouse press/release/doubleclick/move event, the row and tree branches(grew lines) can be redraw by overriding drawRow/drawBranches function.

Others:

1. 之前假如不是跟geometry/mesh相关的工作，我都有一点点抵触, 觉得不对口。现在发觉不能这样子，想做跟geometry/mesh相关的工作内容是因为想在那方面做深入, 但是有时候做做别的东西也能扩展知识面, 而且东西都不是独立而是相联系的。例如现在在看Qt的model/view architecture, 从pattern从编程方面都是会有益的。例如做paint layer blend mode, paint layer transfer, layer mask就能扩展texture/material这方向的认识。

2. 写代码，接触一个feature甚至是fix 一个bug时候，一定要进行做的完善完美鲁棒, 否则之后的bugs会不断过来，弄得无法开始or专心于下一步的工作。

3. 要到LayerModel/LayerView(custom 的Model/View)中加入新的model item, 而且这些item还是新的类型, 于是觉得：冷静->逻辑清晰->快速的理解能力很重要.

4. 想起了去年面试被问过的一个question: 给出三角形的三个边长, 怎么求出三角形的面积?
假如在初高中时候要是这个问题都不懂的话肯定考不上大学，如今却真的模糊了。后来复习时候发现那个公式原来有个不错的名字Heron’s (or Hero’s) formula. A=sqrt(s*(s-a)*(s-b)*(s-c)), where s = (a+b+c)*0.5, http://en.wikipedia.org/wiki/Heron's_formula, 链接中还给出了利用余弦定理law of cosines的证明(这个更重要). 这些其实都是应该牢记的。最后提到了这个公式的数学稳定性不好numerically unstable, http://en.wikipedia.org/wiki/Numerical_stability, 里面对一个array 求sum的例子不错, 求一百个数, 假如一个是1，另外99个都是0.01，精确解释1.99，但是看上去正确的算法得到的结果不同，有些甚至是错误的(错误的是先加1再加0.01, 较好的做法是先排序, 从小到大来加. 排序?复习)。这可能是2进制计算机中由于round-off error and truncation error而引入的 (ok, 又涉及到了floating point numer了, 怎么表示，跟0的比较，之前看过一个用它生成random number的)。
然后又从truncation提到了Taylor series (这个我在研二暑假找实习时候被问及), 除了能写出这个公式之外，还得想想它有什么实际用处. (1). F(x) = F(a) + F’(a)x +…当 a=0时候就变为Maclaurin series, 然后就可以求例如the exponential function e^x的近似值了, sin(x)的近似值等。

5. 有这么一个Camera model, 有意思的是我想在初始化时候都是给出position, target等参数parameters, 但是这个camera model中确实根据给出的scene center and scene radius来计算那些参数.

6. Tree data structure.

for example, max-heap is a complete binary tree, which used to build the priority-queue;

the RB-tree is binary search tree, which is used to build the set and map container.

there are many other examples of course. scene tree...

add model list

2010-08-22T18:03:00.002+08:00

Weekly update - 2010/8/16

2010-08-20T18:58:00.002+08:00

Basic shader manager and vertex batch
There are many things to learn and do. In order to render the curvature tensor, which is property of mesh, i need to add shader step-up and organize the vertices from curvatures into vbo (OpenGL 3.x is used).
However, there is already shader step-up and vbo using in the scene::render(), i don’t want to duplicate the code in the class Model. So, shader manager and vertex batch classes are need.
After googling, i come across to http://www.informit.com/articles/article.aspx?p=1616796&seqNum=4, the free chapters of OpenGL SuperBible 5th, and the greatest thing is its code is stored in google code project, from where i can download it. Must read!
Another resource is http://prideout.net/blog/?p=22 (anti-aliased cel shading, and shader wrapper).

Expected result:
1. Refactor the shader loading, create the batch class, render the scene(world frame, grid, mesh) using this new one.
2. render the curvature tonsor.
3. integrate the anti-aliased cel shading.

Notes:
1. there are two ways to get the vertex attribute location(index). The explicit way, use the
glBindAttribLocation(uint program, int index, char *name);
The inexplicit way, use the
int index = glGetAttribLocation( uint program, const char *name );
the index will be used later by puting vertex data into it.
2. To render the model, there is only mesh data at the current time, which is a polygon/n-sided mesh, using GL_TRIANGLES, a triangle mesh is created. The triangle mesh is used exclusively on rendering, but the mesh adjacency information is not used so data is wasted to record that. After integrate the GLBatch from GLTools of OpenGL SuperBible 5th, I wonder how about remove the triangle mesh, put the triangle data of the polygon mesh into the a instance of class GLBatch.
After further investigation, it is found that there is no index buffer object in the class GLBatch, for example if a quad is needed to be drew, six vertices are needed, and the
glDrawArray(GL_TRIANGLES, 0, 6);
is used. There are two vertices are duplicated. The GLBatch cannot be used directly.
But the triangle mesh is still needed to be removed. I want to create a vertex batch for all the vertices data, and create two index buffer object, one for regularly drawing triangle(GL_TRIANGLES) and one for drawing polygon wireframe(GL_LINES).

2010/8/17

Curvature tonsor

The principal curvature directions (red line for KMax, green line for KMin) are renderred using the the flat shader of the stock shaders in GLTools/GLShadermanager.h/cpp.

To build up the 3*3 tensor matrix (used by the Normal Cycle approximation algorithm), need to loop and search a neighborhood region of a start vertex.
push the start vertex into a stack (why use stack);
while stack is not empty
v = pop up the top vertex;
loop the one-ring neighbor of v;
if the neighbor meets the qualify, operate on it and push it into stack.

This search algorithm remind me of the Dijkstra’s algo.

To improve the curvature quality, some smoothing steps are need.

Triangle is evil?
Doing with mesh, i always asking why the quad mesh is used so often and i saw most of the model created by so-called artist are quad mesh, not triangle mesh, not even the n-sided mesh.
Maybe, this is one of the reason.
(a). Two quad faces share one edge, it is easy to set these two faces are symmetric.
(b). Tessellate those two faces in (a) into triangles, what happen the red triangles are set to symmetric? It’s wrong i guess, the topology are not symmetric, though the vertices are symmetric.
(c). even worse.

Thinking about managing ImageFilter/MeshBrush
In the plugin “Image Filter Tool”, there are some image filters can be applied to the image. There is a base class ImageFilter, i can write derive class of it in another plugin(dll) to define new image filter. My question is after the new image filter type is defined, how to add it into the main application, and create ui(for example button, or combo item) for it?
The function registerImageFilters(...) can be put into a ImageFilterFactory class as a static member functon:
typedef (ImageFilter *)(FuntionPointer)();
void ImageFilterFactor::registerImageFilter(string name, FuntionPointer funcPointer);

Can it be better?
(1). do not create the instance until the filter is selected.
(2). do not use the callback function to create the instance in plugin, but use running time type info(rtti) to create a instance in the main application. Declare a new image filter like this:
class ImageFilter : public XObject {
X_OBJECT
...
};
in plugin:
class XImageFilter: public ImageFilter {
X_OBJECT
...
};
Something looks like the object system in Qt :-) then the XImageFilter type is added into the object system, later we can check whether we have a type named “XImageFilter” in the object system, if yes, we use:
ClassInfo * findClassInfo(“XImageFilter”);
ImageFilter *pIF = pCI->createInstance();

Recommended book: Design of Design http://www.informit.com/store/product.aspx?isbn=0201362988 sample chapters are on the right hand side.
(some one said “Run, you run” can be translated into 跑啊, 你丫快跑啊:-)

Bug Series - angle between two vectors

2010-08-20T18:57:00.000+08:00

float dot = dot(v0, v1);
float radian = acos(dot);

more safe:
dot = Max(-1, Min(dot(v0, v1), 1); // make sure the dot is [-1, 1].
radian = acos(dot);

https://docs.google.com/document/pub?id=1KyKbHUXfrXh-7L0g4cP-l2QcqVDsmYPTyBJXjGAtXhA

Bug Series_Programing_link error_unresolved external symbol

2010-08-20T18:56:00.000+08:00

之前
最上层的基础库都是static library(.lib), 中间的core要是static library(.lib), 然后被应用层的main.cpp直接生成application.exe.

这么弄一直没有问题, 直到...
直到我想加入一个ImageEditor的plugin, 作为一个dynamic library(.dll)存在, 这个plugin需要使用core提供的interface来调用application里面的类和member function, 而core在里面也需要能检查到这个加入的plugin并使用它。

compilation没有问题，但是在link时候就出错了:

error LNK2019: unresolved external symbol "__declspec(dllimport) public ...

后来发现那个core作为static library是有问题，因为static library不能包含别的static library和dynamic library . 于是我把core作为dynamic library就ok了.

但是这样又引入了新的问题, dynamic library需要导出一些接口，别的.dll/.exe才能使用, 否则例如main.cpp和ImageEditor中就不能使用了。
于是就引入了__declspec attributes.

http://blog.csdn.net/alicehyxx/archive/2010/01/08/5161868.aspx
http://msdn.microsoft.com/zh-cn/library/9h658af8(v=VS.80).aspx
http://msdn.microsoft.com/zh-cn/library/z4zxe9k8(v=VS.80).aspx
http://msdn.microsoft.com/zh-cn/library/fdy23fx6(v=VS.80).aspx
http://msdn.microsoft.com/zh-cn/library/a90k134d(v=VS.80).aspx
http://msdn.microsoft.com/zh-cn/library/900axts6(v=VS.80).aspx

Math Series - Cycloid 摆线轮滚线

2010-08-20T18:12:00.001+08:00

想象这么一个情景：车子来开，一个车轮压到地面的口香糖，口香糖粘到轮子上了（会这样子么？) 假如问轮子转一圈之后口香糖划过的距离长？:-)

首先这个划过的曲线叫做轮滚线，一个很形象的名字，至于那个长度怎么求了嘛，以及这个曲线跟地面的面积怎么求，请看:
http://tutorial.math.lamar.edu/Classes/CalcII/ParaArea.aspx and the next section.

https://docs.google.com/document/pub?id=1R4C7rCr7HguVIxUMVHHXl_f7ehMATFGUPBeOqpmTiQI

interesting stuff about geometry

2010-08-03T17:22:00.003+08:00

1. a mesh composes of vertex attributes(geometry information) and adjacency(topology information). How about compress they independently? http://openctm.sourceforge.net/

2. Some special mesh can be generated automatically, does not need to add faces/vertices manually. check http://prideout.net/blog/?p=44 and http://structuresynth.sourceforge.net/

3. I'm always interested in the geometry engine of CAD or something like that. http://wildcat-cad.blogspot.com/

To render the vertex

2010-06-20T15:44:00.004+08:00

目的是用OpenGL 3.2来画东西, 而不是glVertex, glColor.

Step 1:

准备Vertex Data:

(1). vertex count 有多少个数据? (2). 具体的vertex data, （3）这些数据的大小(in byte)

例如:

const GLint coordinateLineVertexCount = 6;

const GLint coordinateLineVertexSize = sizeof(dgp::vec3f) * 2 * coordinateLineVertexCount;

dgp::vec3f coordinateLineVertexData[] = {

// vertex position // vertex color

dgp::vec3f(0, 0, 0), dgp::vec3f(1, 0, 0),

dgp::vec3f(fLength, 0, 0), dgp::vec3f(1, 0, 0),

dgp::vec3f(0, 0, 0), dgp::vec3f(0, 1, 0),

dgp::vec3f(0, fLength, 0), dgp::vec3f(0, 1, 0),

dgp::vec3f(0, 0, 0), dgp::vec3f(0, 0, 1),

dgp::vec3f(0, 0, fLength), dgp::vec3f(0, 0, 1)

};

注意每一个vertex data包含了两部分, position and color.

Step 2:

生成一个buffer object放这些vertex data.

Step 3:

生成一个shader program，

Step 4:

当真正需要render的时候, 往shader program的相应的location里面写入对应的数据.

例如: projection matrix, model view matrix, the vertex data (position, normal, color) ....

然后指定画成什么primitive形式。

使用glVertex的特点是容易入手, 现在需要自己手工来完成上面好几个steps才可以。但是特点是思路很清晰，先打包好vertex data，往shader program里面放这些数据，条理清晰。

相对于glColor来给出顶点的颜色, 在shader里面的做法我用了下面三种最简单的(每一种对应一个shader program)：

例如图中的Grid，all the vertices are the same color, they are same color in fragment too, 所以我在fragment shader中用了一个uniform vec3 fragmentColor;程序中指定这个颜色，黑色，就ok了。

例如图中的coordinate system line，一个红线，一个绿色的线，一个蓝色的线。就需要每一个vertex 给出 color 信息. vertex shader 中:

in vec3 position;

in vec3 color; // 之后取他们的location并写入准备好的data.

例如图中的Cube, 用Blinn Phong lighting，fragment shader中计算color.

Thinking about Singleton

2010-06-18T23:50:00.002+08:00

1. The constructor should not have parameters?

In the GoF Design Patterns, there is no parameter for the constructor. That makes it very easy, because the constructor is invoked by the instance() method, if the constructor needs parameters, do we send the parameters to the instance() method, which pass them to the constructor? It is not clean and clear.

class Singleton {

public:

static Singleton *instance();

protected:

Singleton();

private:

static Singleton *s_pInstance;

};

But if the the constructor do need some parameters, how to do that?

2. The constructor need to be protected/privated?

In the GoF Design Patterns, the constructor is protected, which make sure that the clients (from outside) can not instantiate objects directly.

But if we want to create a new Singleton instance?

class Singleton {

public:

static Singleton* createNewInstance();

static Singleton* instance();

protected:

Singleton();

private:

static Singleton *s_pInstance;

};

The following is an example. For example, a new scene is created whenever a scene file is loaded/read.
Scene* Scene::s_pThis= 0;

Scene* Scene::instance() {

if (s_pThis) {

return s_pThis;

} else {

return createNewScene();

}

Scene* createNewScene() {

if (s_pInstance ) {

// delete, this will call the deconstructor.

delete s_pThis;

s_pThis= 0;

}

s_pThis= new Scene;

return s_pThis;

}

In this case, the instance() returns the object instance which is active, others are discarded.

And in this case, we can change it a little bit:

(1) firstly, call this method to create instance.

static Singleton* createNewInstance(...parameters...);
(2) call the instance() use the instance object.

This makes a assumption that, create it before you use it.

3. The copy constructor and assignment operator ?

See this example:

Scene s = *Scene::instance(); // this will call the copy constructor.

Scene s; // this will call the default constructor.

void functionX(Scene s) {

s is a temp instance object...

}

functionX(*Scene::instance()); // this will call the copy constructor;
Maybe, it would be safer to private these two methods.

4. How about the s_pInstance in derived class?

Math Series - Quadratic equation

2010-06-16T14:29:00.002+08:00

the solutions are:

初中的二次方程啊:-) 我们都知道怎么解，但是有没有想过怎么建立这个方程式呢？It is meaningless until we know how to build it.

Case 1. Points on a sphere, and Ray - Sphere intersection.

http://www.siggraph.org/education/materials/HyperGraph/raytrace/rtinter1.htm

Bug Series - 无效的int变成了有效的unsigned char

2010-06-11T22:07:00.002+08:00

Today, i came across this kind of bug:

int iIndex = -1 ;// -1 means invaluable value. >=0 means valuable.

unsigned char ucIdx = iIndex;

if (ucIdx >= 0) { // this is error-prone, most of time ucIdx >= 0 is true.

do sth here;

}

When iIndex = -1, the ucIdx is 255, so even you think iIndex is invaluable, but the ucIdx >= 0 is ture, so error happens.

Why?

Take a two bits value as an example. 2 bits can express 4 values,

unsigned: 00, 01, 10, 11

0, 1, 2, 3.

signed: 11, 00, 01, 10

-1, 0, 1, 2.

It is clear that the signed value -1 means 3 at unsigned value.

so, the ucIdx = iIndex = -1 means 255, which obviously/obviously >= 0. The bug comes from here.

Bug Series - 数组变小了

2010-06-11T21:36:00.002+08:00

Let see look the a tree structure first:

一个Scene底下有两个geometry, 后来在Scene下还多建立了一个Skeleton来做skinning, 这个skinning与那两个geometry有关，是作用于它们上面的, 具体的skinning操作变换在各自的SkeletonReference中。

并且为了记录这个Skeleton 是操作哪些Geometry的，于是Skeleton有一个成员m_arrGeo[]是一个数组, 这个例子中记录的是两个指针.

下面的问题是: 我要删除这个skinning操作, 也就是将Skeleton和两个SkeletonReference删除掉.

code:

for (int i = 0; i < skeleton->m_arrGeo.size(); ++i) {

delete skeleton->m_arrGeo[i]->skeleton_reference;

}

delete skeleton;

这个代码段在Skeleton只作用于一个Geometry时候运行正常, 但是当作用于两个和多个Geometry时候就错误了(错误是隐晦地遗留到后面别的地方才造成的，不是在这里就造成，这才是恐怖的地方).

for (int i = 0; i < skeleton->m_arrGeo.size(); ++i) {

print out the size = 2;

delete skeleton->m_arrGeo[i]->skeleton_reference;

print out the size = 1;

}

delete skeleton;

可见问题在于 after executing the blue line, one element has been removed from the array. so let take a look at the de-constructor of SkeletonReference.

~SkeletonReference() {

find if the parent (the Geometry_i) is in the m_arrGeo[],

if yes, remove it.

}

Actually, this method makes sense, because when a geometry do not possess a SkeleteReference, there is no need to be recorded in the m_arrGeo[] array.

So, the problem is in the for sentence.

for (int i = 0; i < skeleton->m_arrGeo.size(); ++i) {

// we are iterating a dynamic array.

// we can not make sure that we can visit all the elements.

...

}

change it to:

std::vector<Geometry *> arrGeo = skeleton->m_arrGeo;

for (int i = 0; i < arrGeo.size(); ++i) {

// this is right.

delete arrGeo[i]->skeleton_reference;

}

ComboBox - model/view

2010-06-07T23:43:00.002+08:00

array E[]中有一些元素，希望放到一个ComboBox中可以让用户来选择用哪一个.

但是有时候E中有些元素有不想显示在ComboBox中.

这里的解决方法是将某一部分ei作为itemI, 当用户选择了某一个item时候返回其string,再到E中找对应的idx.

Bug Series - crash at delete pointer

2010-05-30T23:23:00.002+08:00

void Scene::setCamera(Camera *_camera) {

if (m_pCamera) {

delete m_pCamera;

m_pCamera = 0;

}

this->m_pCamera = _camera;

}

这个是错的, 因为第一次到if时候, m_pCamera之前不一定是new出来的而因为垃圾数据而非零, 于是在delete时候就crash了.

所以m_pCamera需要在构造函数中初始化为0.

Gaussian Blur

2010-05-16T10:39:00.002+08:00

需求: 在看OpenCL的Gaussian Blur例子.
基本概念看http://en.wikipedia.org/wiki/Gaussian_blur，有一个新的概念是linearly separable, 原本是一个有权值组成的方形矩阵来对周围的pixel做加权和，现在分开horizaontal and vertical direction方向各一个pass来先后做，好处是什么？提高performance, 对每一个pixel的求值从width * height个乘法降低到width + height个。

例如对于blur宽度是5的情况, 有以下两个预想求得的table值（取不同的宽度值就对应不同的两个tables. 至于这些table值是怎么求出来的，standard deviation去什么值, 是不是直接代入坐标算出来的呢?有待考证）：

static float const blurOffsets5[] = { -4.37988, -2.43235, -0.486391, 1.45925, 3.40585, 5 };

static float const blurWeights5[] = {0.0953448, 0.200199, 0.275104, 0.24745, 0.145682, 0.0362198 };

那么水平(or 竖直)一个方向的blur结果就是:

for (index = 0; index < 5; ++index) {

pixel += read_imagef(srcImage, 当前坐标 + (float2)(blurOffsets5[index], 0.0f)) * blurWeights5[index];

}

左边是原图，右边我做出来后倒是像某种海底的浮游动物。

另一个话题 Guassian distribution,(normal distribution).

一维情况下，这个高斯分布(正态分布)的curve的函数是 .这个curve的特点包括the total area under it is equal to one. 为什么需要这个requirement呢? 很可能是因为Guassian函数作为probability distribution functions的一种，而后者有这个要求，那Gaussian函数自然也需要满足. 那个mean 控制是curve的中心值, 而standard deviation控制的是曲线形状的宽度.

那么为什么高斯分布在自然中这么常见呢？甚至说一个学校里面学生的考试成绩也是成高斯分布。Central Limit Theorem 是一种解释. "In its simplest form, the Central Limit Theorem states that a sum of random numbers becomes normally distributed as more and more of the random numbers are added together. It does not require the individual random numbers be from any particular distribution, or even that the random numbers be from the same distribution"[The Scientist and Engineer's Guide to Digital Signal Processing, Steven W. Smith].

How to locate the work item in OpenCL?

2010-05-15T14:22:00.002+08:00

How to locate the work item in OpenCL?

- Reading Notes of OpenCL Specification version 1.0.

Global ID: A global ID is used to uniquely identify a work-item and is derived from the number

of global work-items specified when executing a kernel. The global ID is a N-dimensional value

that starts at (0, 0, 0). See also Local ID.

Local ID: A local ID specifies a unique work-item ID within a given work-group that is

executing a kernel. The local ID is a N-dimensional value that starts at (0, 0, 0). See also

Global ID.

Work-item: One of a collection of parallel executions of a kernel invoked on a device by a

command. A work-item is executed by one or more processing elements as part of a work-group

executing on a compute unit. A work-item is distinguished from other executions within the

collection by its global ID and local ID.

a single work-item can be uniquely identified by its global ID or by a combination of its local ID and work-group ID.

Each work-item is identifiable in two ways; in terms of a global index, and in terms of a work-group index plus a

local index within a work group.\

下图显示这些id的计算:

uint get_work_dim(); Returns the number of dimensions in use.

size_t get_global_size(uint dimindx);

图中是 Gx * Sx = get_global_size(0); Gy * Sy = get_global_size(1); 一行or一列的总的items数目.

size_t get_gloabl_id (uint dimindx);

例如上图中gx = get_global_id(0); gy = get_global_id(1); 一行or一列中的第几个.

size_t get_local_size(uint dimindx);

图中的 Sx and Sy. 表示一个work group中一行的items数目or 一列的items数目.

size_t get_local_id (uint dimindx);

例如上图中sx = get_local_id(0); sx = get_local_id(1); 表示某一个work group中一行or一列中的第几个.

size_t get_num_groups(uint dimindx);

图中的 Gx or Gy. 表示每行or每列有多少个work group.

size_t get_group_id(uint dimindx);

图中的wx or wy. 表示一行or一列中的第几个work group.

这些build-in function是足够计算几种id的转化了.

global_work_size: points to an array of work_dim unsigned values that describe the number of

global work-items in work_dim dimensions that will execute the kernel function. The total

number of global work-items is computed as global_work_size[0] * ... * global_work_size[work_dim - 1].

我理解在上图, work_dim 就是2指二维, global_work_size[0] = Gx, global_work_size[1] = Gy.
这两个值可以通过函数取得: size_t get_global_size(uint dimindx); valid values of dimindx are 0 to get_work_dim() - 1;

local_work_size points to an array of work_dim unsigned values that describe the number of

work-items that make up a work-group (also referred to as the size of the work-group) that will

execute the kernel specified by kernel. The total number of work-items in a work-group is

computed as local_work_size[0] * ... * local_work_size[work_dim - 1].

我理解在上图, work_dim 就是2指二维, local_work_size[0] = Sx, local_work_size[1] = Sy.

这两个值可以通过函数取得: size_t get_local_size(uint dimindx); valid values of dimindx are 0 to get_work_dim() - 1;

local_work_size can also be a NULL value in which case the OpenCL implementation will

determine how to be break the global work-items into appropriate work-group instances.

If local_work_size is specified, the values specified in global_work_size[0], … global_work_size[work_dim - 1]

must be evenly divisible by the corresponding values specified in local_work_size[0], … local_work_size[work_dim – 1].

这个就很容易出错了, 例如一个image是300 * 300, 我就不能设置local size为 8 * 8.

premultiplied alpha

2010-05-08T13:11:00.004+08:00

什么是Compositing (Alpha Composition) ?

"Compositing is the process by which graphical objects are combined. Alpha compositing uses the alpha values, or channel (bit mask) to represent the coverage of each pixel. The alpha channel is often said to represent the 'opacity'. This coverage information is used to control the compositing of colors. " [2]

"In computer graphics, alpha compositing is the process of combining an image with a background to create the appearance of partial transparency. It is often useful to render image elements in separate passes, and then combine the resulting multiple 2D images into a single, final image in a process called compositing."[1]

平时我看到的alpha blending好像就是所谓的simple alpha compositing, 好像就是Porter-Duff paper中的over operation.[2]: http://www.svgopen.org/2005/papers/abstractsvgopen/simplealpha.png

涉及在对两个bitmaps做blending的时候: 左边的表述是已有的底片，右边的表述是要画在上面的,

backdrop layer/source

based image blend image

target source image

framebuffer texel

background foreground

-----------------foreground * alpha

-----------------background *(1-alpha) => result.

想象一种situation，已经在framebuffer上画好了model，上面加一个painting layer，需要将这个painting layer放到上面去。

fig "".

这个图片用到公式就是很常用的，我觉得就是上面讲到的simple alpha compositing. 而且这公式的color compenent是un-premultiplied的，所以公式中加号+后面blend * blend.a.

如果是用了pre-multiplied color compenent的话， result = based * (1 - blend.a) + blend. 这就是Porter-Duffer paper中的"over" operator. 这就说明了我们平时常见的blending和Porter-Duffer compositing的关系了，并不contrary矛盾的。

Classic paper: Compositing Digital Image, 1984. http://keithp.com/~keithp/porterduff/
第2节The Alpha Channel 解释了为什么需要因为alpha channel，因为需要"retain the matte information. the extent of the coverage of an element at a pixel. An alpha of 0 indicate no coverage, 1 means full coverage, fractions corresponding to partial coverage."

里面有一个问题: "how do we express that a pixel is half covered by a full red object?

One obvious suggestion is to assign (1, 0, 0, .5) to that pixel: the .5 indicates the coverage and the (1, 0, 0) is the color.

There are a few reasons to dismiss this proposal, the most severe being that all composting operations will involve multiplying the 1 in the red channel by the 0.5 in the alpha channel to compute the red contribution of this object at this pixel. 这种un-pre-multiplied alpah的表示方式的缺点是每次做compositing时候都需要乘以alpha.

The desire to avoid this multiplication points up a better solution, storing the pre-multiplied value in the color component, so that (0.5, 0, 0, 0.5) will indicate a full red object half covering a pixel."

然后区分了两个:

black = (0, 0, 0, 1); // an opaque black, alpha = 1 means full coverage = opaque.

clear = (0, 0, 0, 0); // transparent.

什么是"clear"呢? 就是下面看到的格子背景(在gimp, photoshop中才能看到的). 我用红色的圈圈表示picker的位置. "transparent pixels cannot be displayed on a computer monitor", so a "checker board pattern" is used.

第4节讲了12种composition operations. 这部分很难懂，需要参考[2],[3],

为什么说12种呢? 组合问题。

并且假如颜色是用了pre-multiplied的话, composition后的color and alpha components都是用 equation 1: c0 = c_a * F_a + c_b * F_b来求的。那个F_a, F_b在每一种operator中的取值都不一样，F的意思是"which indicate the extend of contribution of A and B" 跟alpha不是一样的.

"It is important to note that the equations defined by the Porter and Duff paper are all defined to operate on color components that are premultiplied by their corresponding alpha components. "[5] 说Porter-Duff paper中的公式用到是color components are pre-multiplied.

先回顾alpha value的意义啊：这个color component在这个pixel上覆盖了多少, 0表示没有覆盖, 1表示全覆盖.

例如一个pixel上有picture A和picture B两个color component (element) 同时出现了，A.alpha = 1, B.alpha = 1. 这并不conflict冲突的, A的color component full coverage this pixel, and B's color component full coverage this pixel too. 当我们做alpha blending时候我们会先假设一个在某一个上面, 例如A在B上面，如果A.alpha=1，那B就看不到了. 所以我感觉alpha 是说我覆盖占这个pixel多少了, 控制的是pixel的transparency.

再来看over operator, paper p256左边最后几行的公式是:

cO = cA * Fa + cB * Fa, 然后查表(A over B)就可得到Fa and Fb的value，代入公式:

cO = cA * 1 + cB * (1 - aA) = cA + cB * (1 - aA)。

这公式是不是就是看上去很像我们上面提到的simple alpha compositing/blending的线性插值的结果呢? 其实就是嘛。paper的“This is almost the wll used linear interpolation of foreground F with the background B

B' = F * a + B * (1 - a),

except that our foreground is pre-multiplied by alpha.” 公式中的a是指F.alpha, 我觉得.

Until now, 终于将我们平时看到的linear interpolation和Porter-Duffer paper中的over operator联系起来了. 另一个证明, 在[6]中有"'normal' blend mode is equivalent to operator="over" on the 'feComposite' filter primitive, matches the blending method used by 'feMerge' and matches the simple alpha compositing technique used in SVG for all compositing outside of filter effects."

[1] Compositing Digital Image, 1984. http://keithp.com/~keithp/porterduff/

[2] http://www.svgopen.org/2005/papers/abstractsvgopen/index.html

[3] http://en.wikipedia.org/wiki/Alpha_compositing
[4] http://greenshoes.free.fr/dotclear/index.php?post/2008/12/02/Using-alpha-composites-in-PulpCore
[5] http://java.sun.com/javase/6/docs/api/java/awt/AlphaComposite.html 这里也有解释和公式.

[6] http://www.w3.org/TR/SVG/filters.html#feBlend 这是SVG1.1 20030114.

[ ] http://www.mail-archive.com/gimp-developer@lists.xcf.berkeley.edu/msg08096.html GIMP中多个layers时候也是从低往上来做composition的"the layer compositing works from the bottom to the top". 注意这种合并是非associative的，所以次序很关键.
[ ] https://mmack.wordpress.com/ 里面的Sprite mipmaps文中将到pre-mulitplied 的另一个用处.

上面讲了什么是pre-multiplied alpha，也提到了它的一个好处是不用在每次求compositing时候做乘以alpha value. 那么它还有什么好处呢? 这就是下一个话题了.

[] http://www.kxcad.net/autodesk/3ds_max/Autodesk_3ds_Max_9_Reference/premultiplied_alpha_glossary.html

[] http://blogs.msdn.com/shawnhar/archive/2009/11/06/premultiplied-alpha.aspx

[] http://blogs.msdn.com/shawnhar/archive/2010/04/09/how-shawn-learned-to-stop-worrying-and-love-premultiplied-alpha.aspx

[] http://blogs.msdn.com/shawnhar/archive/2009/11/11/premultiplied-alpha-content-processor.aspx

[] http://home.comcast.net/~tom_forsyth/blog.wiki.html#[[Premultiplied%20alpha]]

当然了, 它也有缺点的. "To be clear: premultiplied alpha is not a perfect panacea for all problems".

[] http://kriscg.blogspot.com/2009/11/premultiplied-alpha.html
[] http://msdnrss.thecoderblogs.com/2010/04/08/premultiplied-alpha-in-xna-game-studio-40/

讲完了 what is premultiplied alpha and why it solves all the world's problems. 下面讲一下它跟blend mode的关系，其实我是因为要做blend mode的操作，而1. blend mode的某些操作中用到了over operator等；2. the formulas in that photoshop document are assuming the pixels are unpremultiplied. 3. Mudbox uses premultiplied alpha, so the math will be different in some cases.

才涉及到Porter-Duff Compositing的. 下面回归blend mode.

首先, "While every pixel has transparency information associated with it, every layer also has an associated opacity value. The two terms are similar and in most cases can be treated as the same. You may think of a layer's opacity value as a "dimmer" for the alpha values of every pixel in the layer."http://www.getpaint.net/doc/latest/en/LayersAndBlendModes.html

下图说明Opacity是layer的属性, alpha是pixel的属性. 合成时候貌似是:

先f' = foreground image * opacity，再来用这个f'去继续的.

svg的specifications都是用pre-multiplied的.
在svg 1.1 中[http://www.w3.org/TR/SVG11/filters.html#feBlend, http://www.w3.org/TR/2003/REC-SVG11-20030114/filters.html#feBlend 这两个是一样的]中可以找到normal, multiply, screen, darken, lighten的公式，都是premultiplied的, 相关的实现在google code search中找nr-filter-blend.cpp 可以找到。是不是意味着在svg 1.1中只是支持这5个Porter-Duff操作呢? 后面提到1.2版本做了扩展的.

在svg filter 1.2 [http://www.w3.org/TR/2007/WD-SVGFilter12-20070501/#feBlendElement] 中也一样，
但是在svg 1.2[http://www.w3.org/TR/2004/WD-SVG12-20041027/rendering.html]就好像对alpha compositing做了扩展，加入了Compositing module.

[http://www.svgopen.org/2005/papers/abstractsvgopen/]里面有一些介绍和解释。

这里给我的感觉就是后续的出现在PDF specification中的其它例如darken/lighten, soft light等都是Porter-Duffer 之后的扩展, 如上说的Normal mode就是Over operator.

上面那是svg的specifications, 至于具体在一个library中怎么实现，那还是有区别的.

下面看看Cairo的实现(它利用了一个叫做Pixman: the pixel-manipulation library for X and cairo的库).

首先, 貌似是Benjamin Otte这家伙(后来在red hat中上班)在Cairo中加入blend mode的(March 2008, http://old.nabble.com/Blend-modes-td15856879.html ), 然后他发现了SVG标准中的soft-light mode跟PDF中描述的algorithm不一样，所以在October 2008就给SVG提了个建议:

下面就是Benjamin提出问题的地方.

http://lists.w3.org/Archives/Public/www-svg/2008Oct/0029.html Benjamin在这mailing list里提了问题 (然后被SVG里面的人 raised as issue 2095). 顺着这个mailing list下去会看到有人会回应的, 在http://lists.w3.org/Archives/Public/www-svg/2008Oct/ 页面中搜索blend 或者 soft关键字，一直到2009年Feb 12号的http://lists.w3.org/Archives/Public/public-svg-wg/2009JanMar/0132.html.

[之后被raised 作为issue 2095], 后面有人跟进:
http://markmail.org/message/f4tsfvm2wjevxyh6#query:+page:1+mid:vuxzgn53rls7aq3o+state:results 这里面Alex Danilo的回答"while I was working on this, we had to deduce the functions from various sources, since the equations were not published. The starting point was some Japanese site that had reverse engineered the equations from looking at Photoshop. We extended the base equations to include alpha correctly." 可见SVG初始的实现(2002年)是对Photoshop做逆向工程得到的, 而且考虑了pre-multiplied alpha, 然后Alex他还给出了soft-light的公式(可能是逆向工程得到的, 这公式就是上面提到的svg 1.2 http://www.w3.org/TR/2004/WD-SVG12-20041027/rendering.html中所用的公式). 之后Benjamin又给出了他根据PDF specification推导的公式(这公式就是他在pixman-combine32.c代码中所用的), 后来Anthony Grasso 在2009 Feb 12又给出了他根据PDF specification推导的公式, 讨论时候还提到的 Color Dodge and Color Burn的公式，Benjamin和Anthony对这两个公式是没有异议的.

他们SVG Working Group 后来还在Teleconference中提到了这个问题, 在http://www.w3.org/2009/02/16-svg-minutes.html 页面中找soft-light关键字.

他们比较完整的email整理在http://www.w3.org/Graphics/SVG/WG/track/issues/2095

上面的公式都是从un-pre-multiplied格式中他们自己推导过去的，原始的公式和参考文档Benjamin Otte在:

http://lists.freedesktop.org/archives/cairo/2008-October/015362.html 里面提到Adobe PDF specification分别是[http://www.adobe.com/devnet/acrobat/pdfs/PDF32000_2008.pdf chapter 11] and [http://www.adobe.com/devnet/pdf/pdfs/blend_modes.pdf] 估计Photoshop也是类似的算法.

GIMP, 18 Oct 2008也对Benjamin的实现有点兴趣，于是有了http://www.mail-archive.com/xorg@lists.freedesktop.org/msg01141.html，他们也支持svg 1.2中使用的公式有点旧了, 而PDF specification是2008年出来，更新一点. 而且他们讨论了觉得大部分的formula都是对的，那两个来自Flash的Invent和谁是PDF spec里面没有的.

至于推导公式的细节，就找不到了. 自己做一下试试.
首先，在PDF32000_2008(所谓的PDF Spec)P322中给出了basic (colour) compositing formula:

然后在P328中说"The preceding formula represents a simplification of the following formula, which presents the relative contributions of backdrop, source, and blended colours in a more straightforward way":

这公式其实更好，为什么呢？

我暂时觉得有两个原因.

1. 例如我们已经画好了backdrop，然后在上面多加一个source(以layer形式出现), 并且这个source中不是整个图片都是有painting结果的(例如这个layer是用stroke做painting画出来的), 在stroking不到的部位就为clear(0,0,0,0)全透明full transparency. 看下面我在GIMP中例子:

图中有two layers, 上面一个作为source layer它的大部分区域都是全透明的，alpha=0, 注意它的color component=(0,0,0)是黑色，假如我们做blending时候用到了这个黑色的话，那效果就不好了，因为本来它是全透明的，底线的background应该不受影响的.

那么上面的p328的公式就比p322的公式更准确了.

2. p328的公式前半部分更容易转化为pre-multiplied alpha的形式. 看下图:

其实在pixman-combine32.c代码中， Benjamin做实现时候大部分的blend mode就是用了pre-multiplied format的blending mode function. 然后Color, Luminosity, Saturation, Hue这四种blend mode是例外, 还是照着PDF一样用non-premultiplied colors. 前者和否则分别对应他代码中的PDF_SEPARABLE_BLEND_MODE和PDF_NON_SEPARABLE_BLEND_MODE。

我需要猜懂他为什么得到这样的结果，并且在上面也说了对于soft light 也要格外小心 “Anthony Grasso 在2009 Feb 12又给出了他根据PDF specification推导的公式”。
有一点其实挺奇怪的是，上面的pre-multiplied format公式中前面的一部分就是Porter-Duff paper中的XOR operator, 应该不是巧合coincidence吧，是什么原因呢?

pic, pic,

上面列举了几个简单的blend mode 从non-premultiplied 到 premultiplied的转化，下面看看复杂一点的例子soft light blend mode.

// B is the backdrop image, S is the source layer image.
float3 Bca = backdrop.rgb; float Ba = backdrop.a;
float3 Sca = source.rgb; float Sa = source.a;
float3 tmp = Bca * (1 - Sa) + Sca * (1 - Ba);

if (Ba < 0.001 || Sa < 0.001) {
// when either Ba and Sa is zero, Ba * Sa * Blend(Bc, Sc) = 0.
// so the color is XOR of Bca and Sca, which is the current tmp value.
} else {
if (2 * Sca.r <= Sa && 2 * Sca.g <= Sa && 2 * Sca.b <= Sa) {
tmp += Bca * Sa - (Sa - 2*Sca) * Bca * (1 - Bca/Ba);
} else {
float3 D;
if (4 * Bca.r <= Ba && 4 * Bca.g <= Ba && 4 * Bca.b <= Ba) {
D = ((16*Bca/Ba - 12) * Bca/Ba + 4) * Bca;
} else {
D = sqrt(Bca * Ba);
}
tmp += Bca * Sa + (2 * Sca - Sa) * (D - Bca);
}
}
float alpha = UnionOp(Ba, Sa); //Õâ¶«Î÷ºóÃæ»á½²µ½.
float4 result = float4(tmp, alpha)

再回去看看那个XOR operator是怎么回事，下面看看假如Rca = XOR(Bca, Ba, Sca, Sa)的效果:

这样就很直观了，感觉好像就是Layer 全透明(full transparency, clear(0,0,0,0))的地方不影响背景, 公式中解释为Sa = 0, 所以(1 - Sa) * Bca + (1 - Ba) * Sa= (1 - 0) * Bca + (1 - Ba) * (0,0,0) = Bca; 而Layer中非透明的地方，就不好直观地说了，要代入公式来算了。这本例中因为非透明的地方Ba = Sa = 1, 所以结果是(0,0,0)黑色.

上面解决了怎么从basic (colour) compositing formula中求出colour, 在PDF spec chapter 11.3.7.3中讲了result alpha的求法:

Ra = union(Sa, Ba) = Ba + Sa - (Ba * Sa).

这公式很像求color时候用的scree blend mode. “The result tends toward 1.0: if either input is 1.0, the result is 1.0”.

于是最后的结果应该就是: (Rca, Ra), in premultiplied format.

扩展:

Quartz 2D是 mac/iphone上的graphics render engine, 不开源的,

http://developer.apple.com/mac/library/documentation/GraphicsImaging/Conceptual/drawingwithquartz2d/dq_paths/dq_paths.html 页面中找"blend mode" 可看到介绍.

Cairo 是跨平台的, 应用广泛，例如在Mozilla Firefox, GTK/Gnome, OpenOffice中用到了,
http://cairographics.org/operators 这是blend mode的例子.

SKia图形引擎, 在Google Chrome/Android中用到了.

Laplacian Mesh Processing

2010-04-25T13:59:00.002+08:00

Laplacian Mesh Processing Olga Sorkine, EuroGraphics '05, State of The Art Report

用Laplacian operator 来 differential surface representation of a mesh:

vertex position vi=(xi, yi, zi) is Cartesian coordinate defined Cartesian space,

we can define a differential coordinate of vi in differential space:

将所有顶点放一个n*1的向量中，将这个Laplace operator放到一个n * n的Ls matrix中，就可以表示整个mesh的Laplacian coordinate.

从两个角度来看这个Ls matrix。

角度 1. 可以called the topological (or graph) Laplacian of the mesh. 它具有的一些properties例如：

Ls matrix is singular, we can't restore the global coordinates only given a set of laplacian-coordinates. 为了解决这个问题，在Ls这个symmetric matrix中加入constraints，成为一个least-squares equations.

角度 2. from a differential geometry perspective this coordinates can be views a discretization of the continuous Laplace-Beltrami operator[dC76], if we assume that our mesh is a piecewise-linear approximation of a smooth surface. 见Fig 1.
文中还提到geometric discretizations fo the Laplacian have better approximation qualities. 这里所谓的逼近是对假设的那个smooth surface来说的。列举的两种geometric discretizations包括:

reference:

Discrete Differential-Geometry Operators for Triangulated 2-Manifolds, Mark Meyer1, Mathieu Desbrun1,2, Peter Schr¨oder1, and Alan H. Barr1,

Mean Value Coordinates, Mean value coordinates in 3D,
M. S. Floater. 里面很多跟MVC有关的paper.

MVC 在‘05被用作deformation了, Mean Value Coordinates for Closed Triangular Meshes.

其实跟Laplacian Operation相关的工作挺多了，还有Laplacian Mesh Optimization, Andrew Nealen, Olga Sorkine and Macr Alexa. 详细的请找Olgo Sorkine的主页.

标签： reading, tech, mesh, laplacian, editting

2010-3-9 有趣的东西-voxel sculptiing

2010-04-21T22:15:00.001+08:00

http://www.3d-coat.com/voxel-sculpting/
读完里面的介绍之后，想法是：
1. 曲线曲面优势是精确度precision, 缺点是(如果算是缺点的话)建模的人要对整个模型有全局的掌握，例如那里是一个角哪里是一个弯哪里是一个洞，而且要对bezier/nurbs的特性这个工具很理解才能用好这个工具。
2. 三角形/四边形，我觉得最大的优势在于直观而且当前的显卡都是对三角形渲染做优化过的。例如以前NVIDIA就做过对四边形渲染做优化的。所谓直观：物体的表面都是用平面来表示，弯曲的地方用多一点小的平面就好了。但是这些polygon组成的mesh，离不开topology。建模的人要想着排线怎么才好，怎么才让四边形的valences少一点。我们呢，想着怎么减少边(simplification)，怎么重新排这些边(quadrangle)，还有想着怎么加一些边(subdivision)等等，貌似都是在做这个topology。那如果topology的生成只是在建模的最后一个阶段呢？
3. 这就来到了voxel了……有这么一个问题：如果你可以对用voxel组成的object(注意不是叫mesh了哦)做动画(voxel的元素不变，只有位移?)，那是不是很新呢？
BTW, 今天sh下雪，漫天纷飞，弄得整个世界都像是voxel组成的，只是密度不一样。

2010-4-8 有趣的-有问题的

2010-04-21T22:06:00.001+08:00

Mari-做阿凡达的3d painting软件

http://media.fxguide.com/fxguidetv/fxguidetv-ep078.mov

我好奇新西兰这个小小小国家这么有创意:-)

本周的问题：
1. 给你一个high-resolution的mesh, 知道它是从low-res mesh经过subd出来的，怎么反求回去呢？

2. 什么是Principal Component Analysis呢？在求Iso-charts (Kun Zhou2004)中用到了，而iso-charts是Direct3D UV Atlas函数的原理。

3. 一个quad-mesh上只用valence=3or4or5的顶点来表示可以吗？在看了一些模型之后，觉得好像在布线时候用这三类顶点就大致够用了。初始的感觉是：3.1 要做一个角的时候, 在例如立方体的角那里，用valence=3来分割三个平面. 3.2 要做一个凸出来部分时候, 用valence=5, 其中四个边是平面的形成基座，那个多出来的第五个边上往上拉往上申出去的, 这第五个边和它左右附近的两个边就形成了那凸出去部分. 3.3 凹进去的部分类似，第五个边是往平面内部申的。纯猜测:-)

smart pointer 随想

2010-03-31T11:04:00.001+08:00

我开始觉得无论是auto_ptr 以及 Reference Counting 其实都是保证只有一个pointer指向pointee/object, 这个object只有一个pointer拥有它的owership. 在auto_ptr中就很明显了, 而在RC中它封装好了这个唯一的pointer, 并通过override那些opertor* ->来让外界使用. 所以不要出现T *pointer = new T这定义, 而是该用Reference ref = new T;
另外, Reference ref本身是作为一个stack上的variable, 那就当然在离开当前scope时候自动释放资源.
RC的想法是：pointer这东西危险，归我保管，但是你们可以借用。
但是并不是什么用pointer的地方都需要用RC来代理, 例如一个Tree中很多Node的pointer，就不需要用RC来代理。为什么？(你想想RC的出发点就知道了:-)

问题-2010/3/31

2010-03-31T11:03:00.001+08:00

std::vector<Position> arr; 内含4个坐标元素.
求四个边v0-v1, v1-v2, v2-v3, v3-v0连起来的是一个四边形，先不考虑凹凸，允许非共面。

SubD + Tessellator unit

2010-02-03T21:48:00.001+08:00

1. subdivision surfaces(subD)的却已经很流行了, 例如Maya, ZBrush, Modo等都支持对这类型曲面操作。这操作暂时多数是局限在high level上增加details, 而不是动态的编辑base mesh来得到新的曲面，为什么呢？第一种操作的base mesh, high level surface是死的死固定的，而后者第二种操作中mesh是改变的，要实时地生成面数目更多的high level是不容易的。

第一种操作，一般是在high level surface增加细节, 然后生成normal/bump/displacement map，连带base mesh一起输出。在后续的渲染中，只要将这些map bake到base mesh就可以了.

2. 虽然subD这么prevalence了, 但是在游戏等实时应用程序中还是以三角片组成的mesh为主，主要原因是什么？其一是底层的硬件主要对三角片渲染做了优化. 所以不管你上层用什么表示方式，最后还是得换成三角片来化，（也是出于这个原因，我觉得point cloud也是, 最后还是三角剖分然后再渲染出来）。Direct3D 11 中加入到tessellator unit好处就是可以在GPU上动态地生成high level mesh(base mesh还是在CPU上)，而不需要在CPU中做好几次subd得到很密的high level然后再放到GPU上渲染。但这里有一个关键点算法，就是high level surface(其实应该说成是limit surface)的参数表示, 因为tessellator unit中的Hull shader需要根据base mesh生成limit surface上每一个patch(曲面片)的参数表示, 例如如果默认是cubic bezier patch，那么只要计算出这个patch的控制点就ok了. (怎么计算呢？后面提到)。得到这些控制点之后，我们等于得到了这个patch的数学表示(Hardware tessellation时候默认是用cubic bezier patch, 14个控制点定了, 特定将这个数学表达式都告诉了GPU), 为了要渲染出来，还是回到要先做三角化嘛。于是就有了后面的Tessellator和Domain Shader, 复杂采样和添加新的顶点.

3. 上面的问题：这么计算出patch的控制点呢？主要地请参考:

[C. Loop, S. Schaefer. Approximating Catmull-Clark Subdivision Surfaces with Bicubic Patches, Siggraphic 2008, the so called ACC]

[C. Loop, S. Schaefer, T. Ni, I. Castano. Approximating Subdivision Surfaces with Gregory Patches for Hardware Tessellation. Siggraphic Asia 2009]

4. 我现在的理解和代码实现还停留在mesh geometry的角度，还没有对加上displacement map之后会产生texture seams有更深的理解.

[AMD. GPU Tessellation for Detailed, Animated Crowds]

[PTex] 这两个文章中都提到了filtering.

2010-2-2.

base mesh --> CPU subd --> hight level mesh --> limit mesh --> vertex buffer / index buffer.

--> CPU calculate the control points for ACC patches, --> Tessellation on CPU --> vertex buffer / index buffer.

--> CPU calculate the control points for ACC patches, --> Tessellation on GPU using bindable uniform buffer(SDK 10) .

--> Hull shader --> Tessellator + Domain Shader --> render.

2010-02-03.

[2010/6/6 updated]

What is tessellation?

在[Real-time Rendering, 3rd]书中的定义比较清晰，记录一下:"To display a curved surface in a real-time rendering context, we usually need to create a triangle mesh representation of the surface. This process is known as tessellation. The simplest form of tessellation is called uniform tessellation." 事实上这书在这方面也讲得相当详细.

What is hardware tessellation?

在[Real-time Rendering, 3rd]书中的说法，记录一下: "An efficient way of providing inexpensive data expansion of geometry is to send higher-order surfaces to the GPU and let it tessellate the surface."

下面来看看tessellation factor的概念.

1. 细分level每一增加一步, 都会增加4倍的三角形数目, 所以tessellation factor就没有必要跟这个subD level一致.

2. 细分level对应每一个边都是一样的, 不利于LOD中adjacent patch的过渡链接, 于是有了像第三个图那样的tessellation方法, 并且三个边可以有三个不同的tessellation factor. 在Direct3D 11中是由hull shader计算出来的, 另一个hull shader需要计算的当然就是control points了.

References:
Moreton H., Wateright Tessellation using Forward Differencing. In Graphics Hardware 2011. 提出了fractional tessellation概念.

http://developer.amd.com/gpu_assets/Real-Time_Tessellation_on_GPU.pdf

Direct3D 11 Tessellation Tutorial: Bill Bilodeau

why to learn OpenGL?

2009-07-10T17:18:00.002+08:00

有点无聊，于是打开了之前收藏的关于opengl tutorials的链接。既然是tutorial嘛，当然很多都是初步介绍怎么使用api等一些基础，于是有点烦。

就想，为什么要学OpenGL呢？
1. 通过学OpenGL来了解Graphics/Rendering Pipeline.
例如在看Essential Mathematics for Grames and Interactive Application时候，那些Transformation, lighting, framebufffer等概念以及计算方式，
要是结合OpenGL的Api，那些原理对应什么api，能达到什么效果，这感觉多好啊。
例如在3D Game Engine Design, second edition时候，那个software render engine，要是结合原理一起看，那估计就深刻了。

2. OpenGL是基础招式，例如C/C++的语法掌握，在此基础上可以去学习很多更复杂的算法、框架和系统等。
例如http://www.paulsprojects.net/opengl/projects1.html这上面就很多特效算法，当然不是为了某几个特别的例子啦，
我估计从它们中可以了解到一类的特效，甚至做一个特效系统，然后特效算法估计也涉及其它更广阔的知识面。

glext; glew, glee这些library的原理

2009-07-10T14:31:00.005+08:00

下面就是glext为我们做的事：
(1), 根据显卡厂商对某个extension的具体说明来定义一些宏.
#define GL_ARRAY_BUFFER_ARB 0x8892 //具体的地址是在各个specification中定义的.
#define GL_STATIC_DRAW_ARB 0x88E4

(2), 声明一些函数指针的类型.
typedef void (APIENTRY * PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer);
typedef void (APIENTRY * PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers);
typedef void (APIENTRY * PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffers);
typedef void (APIENTRY * PFNGLBUFFERDATAARBPROC) (GLenum target, int size, const GLvoid *data, GLenum usage);

然后在我自己的实现中就需要做以下的事:
(3). 声明定义一些函数指针:
PFNGLGENBUFFERSARBPROC glGenBuffersARB = NULL;
PFNGLBINDBUFFERARBPROC glBindBufferARB = NULL;
PFNGLBUFFERDATAARBPROC glBufferDataARB = NULL;
PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB = NULL;

(4). 利用wglGetProcAddress函数取得各个函数的地址指针.
glBindBufferARB = (PFNGLBINDBUFFERARBPROC)wglGetProcAddress("glBindBufferARB");
glGenBuffersARB = (PFNGLGENBUFFERSARBPROC)wglGetProcAddress("glGenBuffersARB");
glBufferDataARB = (PFNGLBUFFERDATAARBPROC)wglGetProcAddress("glBufferDataARB");
而其实在glATI.h, wglATI.h, ATIExtensions.h, and ATIExtensions.c中也是这么做的.

那些glew, glee就将上面4步都给我们做了.

所以当使用extensions时候，
要么是下载glext回来，自己提供源代码实现(3, 4)两步.
要么是直接用glew or glee.

opengl32.dll--Windows系统下OpenGL的实现和扩展

2009-07-09T22:18:00.003+08:00

Windows, OpenGL Versions, and Extensions
这是在http://www.gamedev.net/ 上看到的文章, 这里转帖一下:
Something I've noticed any number of times is that many people are quite vague on how OpenGL works on Windows. This causes a lot of confusion about exactly what the limitations on Windows are with respect to versions, and people tend to say things that don't make sense. The most common misunderstanding is that Windows is limited to OpenGL 1.1. It's time to clear things up.
First, let's start by dissecting the basic OpenGL architecture on Windows. When you build your OpenGL based program, you link to opengl32.lib. This file from the Platform SDK is a companion to the opengl32.dll that ships with Windows. The GL/gl.h header you use matches these two files. When your code runs, some behind the scenes work happens that loads up the functions out of opengl32.dll. However, opengl32.dll is a purely software implementation of OpenGL 1.1, and it's probably not what you want to be using. What you want to be using is the real OpenGL DLL, for example nvoglnt.dll. This file is installed with your video driver.
This is where magic starts to happen. Your calls to opengl32.dll will be redirected to the actual driver specific DLL, which exports at least all the functions in opengl32.dll. The trick is, it also exports a lot more than that. The entire OpenGL API for the version that it supports will be exported, along with all the extensions. Calls to wglGetProcAddress become GetProcAddress calls on the OpenGL DLL that came from the driver. This isn't limited to extensions; you can use it on regular non-extension functions as long as the video driver supports a version of OpenGL that includes them.
The problem here is that, depending on the manufacturer of your video driver and the version, the real DLL that implements OpenGL could be anywhere. Windows provides opengl32.dll as a common place to go to, instead of having to figure out what DLL you need at runtime. That DLL also servves the dual purpose of providing the basic software implementation. That's why it's nearly never been updated; adding new OpenGL functions would mean writing code to implement all of that in software. In Vista they decided to provide a new version built on D3D instead of software, so applications using the Vista headers and libraries can get a baseline of OpenGL 1.4 statically.
All that an extension loader does, then, is to automate the tedious process of making the dozens or hundreds of GetProcAddress calls to retrieve the functions that aren't statically linked and forwarded. Again, these functions don't have to be extensions. You can wglGetProcAddress for glMapBuffer, not just glMapBufferARB. There's no question of what Windows supports. It doesn't matter. The only function you actually need from Windows is wglGetProcAddress, which is your key to accessing the real OpenGL DLL. The rest of the interface is just a convenience in that you don't have to go out and get the addresses for the OpenGL 1.1 functions, since they're already being redirected for you. And since modern extension loaders are machine generated systems that automatically look up everything, it's less relevant than ever before.

Reading note - memory management

2009-07-08T20:24:00.005+08:00

book1: Memory as a Programming concept in c and c++ 已经打印了.
book2: c++ pointers and dynamic menory management. Michael C. Daconta.

Memory location: a container that can store a binary number.
Address: a unique binary number assigned to every memory location. 特别的二进制数。
Pointer: a memory location that stores an address
Variable:a named memory location that can store a value of certain data type..[book2 chapter2]

There is absolutely no difference in functionality between pointers and references. The difference is that with references, the compiler handles the details of passing pointers and dereferencing them instead of you doing it yourself.
1. A reference is an alias for a variable, is not an object, while a pointer is an object. An object has two main attributes: its storage class and its type. The storage class determines the lifetime of this chunk of storage, while the type determines the meaning of values found in the object.
2. References exist only in the compiler and not after compilation. They have symbol table entries only.
3. 初始化时候要给出初值，除了在class中是在初始化列表中的，不能做数学操作.

Array name, is a label, the label of the first address, is not the same as a pointer.

Three memory spaces: [book1,2]
1. global: for global variables(函数之外没有被static关键字的, 函数之内有static关键字的，类声明中static的variables), allocated at compile.
2. stack: activation frame when a function is called, the local automatic variables.
3. free store: binary heap(system heap or free store) at os level keeped by os memory management, dynamic list of free segments at process level keeped by process memory manager.[book1 chapter4].

malloc/new.
malloc 自己用sizeof觉得分配的字节数，返回的是void*，分配得到的空间之内是垃圾数据；
而new在这三方面都有所不同。

Pass by value: cope the variable's content to the activation frame(function stack).
Pass by reference: cope the variable's address to the activation frame.

在datastructure中找linklist的笔记, 也涉及pointer的使用, 学会画图来表示, 32bit里面是variable的地址呢，还是pointer的地址呢?这就是一级pointer和二级pointer的区别。
特别是那个push(struct node *head, int data)的为什么错了, 而需要改成push(struct node **head, int data)?
一定要学着画图, 并且结合以下的概念，
函数传递struct node，那么是将整个structure copy一份到被调用函数的activation frame;
如果函数传递的是struct node*，那么是将structure的地址，也就是指针本身的context copy一份到被调用函数的activation frame;
如果函数传递的是struct node**，那么是将指针本身的address copy一份到被调用函数的activation frame, 这样就修改到指针本身了.

intel relative

2009-07-08T09:33:00.005+08:00

英特尔® 软件网络那个blog的页面上看出来intel的确是在做multi-core的，相对于nvidia的GPGPU.

哲学宗教

2009-06-19T10:11:00.001+08:00

http://www.lib.hstc.edu.cn/dzsk/zxzj/ZXZJ.htm

memory management in c/c++, resources

2009-06-16T13:44:00.011+08:00

1. book, Memory as a Programming Concept in C and C++.

2. book, 程序员的自我修养—链接、装载与库, 第10 章内存.

3. C++ Memory Management: From Fear to Triumph, 3parts.

http://www.linuxdevcenter.com/pub/a/linux/2003/05/08/cpp_mm-1.html?page=1

http://www.linuxdevcenter.com/pub/a/linux/2003/06/19/cpp_mm-1.html

http://www.linuxdevcenter.com/pub/a/linux/2003/08/07/cpp_mm-3.html#twc

4. C++ Memory and Resource Management

5. 内存管理内幕.

http://oiramario.cnblogs.com/archive/2006/01/10/314354.html 整理了很多资料

http://www.gowrikumar.com/c/

http://wangcong.org/blog/?p=291 西邮 Redhat Beijing

http://www.matrix67.com/blog/archives/429 重庆的顾森88年, 这天才好像读北大中文系（2007.9开始），PKU的ACM貌似对他没难度，估计也是高中就天才那种，信息学奥赛，http://www.matrix67.com/blog/archives/319
http://cuitianyi.com 89年高中就acm获奖数学天才，保送ZJU的CS，貌似他们跟楼天成是类似的人物，高手都是在初高中就很出名了，。基础数学-> CS. http://cuitianyi.com/blog/category/life/page/5/，http://cuitianyi.com/blog/%e5%9c%a8%e9%83%91%e5%b7%9e/， : 离散数学，组合数学，数学分析...文理都优秀，在他们的圈子里面很活跃，但估计也有疑惑的时候。：大量，很大量的阅读经典的文史著作和数学著作，算法，编程。：距离一般人有点远，甚至例如家庭条件等就不允许，但是只是程度和轨迹不一样的啦，阅读文史，算法编程还是可以和应该做的。

Apply Game Design as a Science?

2009-06-12T17:00:00.001+08:00

Apply Game Design as a Science for Public Policy to Rescue Economy, Planet.

By Morgan McGuire, Assistant Professor

Nvidia widgets (gui)

2009-04-25T13:15:00.002+08:00

目录结构:

extern/glew
/glut

src/nvglutils/nvShaderUtils.h // dependent on glew
/nvwidgets/nvGlutWidgets.cpp, nvGlutWidgets.h // dependent on glut
/nvwidgets/nvGLWidgets.cpp, nvGLWidgets.h // dependent on opengl
/nvwidgets/nvWidgets.cpp, nvWidgets.h
/examples/example.cpp

类结构:
nvWidgets.h, class UIPainter and class UIContext.

GLWidgets.h, class GLUIPainter: public UIPainter {
//implement all the virtual functions of the base class,
//to draw ui elements with OpenGL.
GLUIPainter();
begin(const Rect &window);
end();
drawXXXX(...);
...
init();//compile and like shaders. invoked by begin(...) function.
};

class UIContext {
//This class is ready for use, but use the GlutUIContext as adaptor.
UIContext( UIPainter& painter ); // use painter(GLUIPainter) to draw UI.
reshape(int w, int h);
isOnFocus();
mouse(int button, int state, ...);
keyboard(unsigned char k, int x, int y);

begin(); //m_painter->begin(m_window);
end(); //m_painter->end();
doLabel(...);// use the painter to drawLabel;
doButton(...);// use the painter to drawButton;
...

UIPainter *m_painter;
Rect m_window;
Point m_currentCursor;
ButtonState m_mouseButton[3];
unsigned char m_keyBuffer[32];
....
};

GlutWidgets.h, class GlutUIContext: public UIContext {
// As an adaptor for GLUT,
GlutUIContext():UIContext(*(new GLUIPainter())), m_ownPainter(true) {}
GlutUIContext(UIPainter &painter):UIContext(painter), m_ownPainter(false) {}
init(); // invoke glewInit();
mouse(int button, int state, int x, int y); //translate the Glut mouse to nvWidgets mouse.
specialKeyboard(int k, int x, int y);
};

小结:
(1)一个负责底层draw UI的类UIPainter，用OpenGL做底层API的话就实现一个GLUIPainter，如果用DirectX做渲染的话就实现一个DXUIPainter.
这个类被UIContext调用。
(2)一个负责管理窗口的UIContext类，工作包括记录自己的windows(大小位置等)，响应keyboard/mouse的输入，对用UIPainter来画UI.
提供了GlutUIContex作为adapter，是否也可以实现Win32UIContext, QtUIContext.
(3)这个nvwidgets目的只是在glut提供的窗口上用OpenGL来画出UI和相应这些UI，
like the author of this project said, it is suitable for small dome.
假如是在Win32上实现，不知是否类似。
假如是在Qt上实现，Qt好像是提供class QPainter to render 2D widgets.
(4)另外，貌似提供的example占用99%CPU.
原来可能是:
static void idle()
{
glutPostRedisplay();
}
glutIdleFunc(idle);
When the application is idle(not responding to event), it refresh constantly(also often used to implement animation).

Email from the author:

That's expected. nvwidgets processes the input and draws the screen
simultaneously. It was designed for real-time applications that are
constantly redrawing the screen, so in those cases that was not an
issue.

This however is one of the main complains people have; there's an
issue already open about it:

http://code.google.com/p/nvidia-widgets/issues/detail?id=1

the IMGUI forums also discuss this issue and propose solutions:

https://mollyrocket.com/forums/viewforum.php?f=10

A simple workaround is not to refresh the screen constantly, but limit
it to 60 or 30 Hz. That can be achieved with WaitableTimers. See the
comment section of the following article:

http://cbloomrants.blogspot.com/2009/03/03-02-09-sleep-sucks-and-vsync-woes.html
另外涉及的link including:
http://meshula.net/wordpress/?p=189
http://www.gamedev.net/community/forums/topic.asp?topic_id=445787&whichpage=2?

问题包括:
(4.1) 游戏shot CPU usage to 100%是否合适? 意见包括对于real-time application来说，this 's not an issue. 反面意见是, the computer's fans roar like a vacuum cleaner. Power consumption. Expecially for a loptop.
(4.2) 如果不想要100%usage, then not to refresh the screen constantly, but limit it to a framerate 60 or 30 Hz. But how? using timer, 方法一般是:
Use a timer to record the time at which you started rendering the current frame. Add 1/120th of a second to that, and you know when the next frame should start.
Once you've finished rendering the current frame, you take the current time, and check how far it is from the "next frame" time we computed.
Then you call Sleep(int) with the time difference.
同样地在上面提到的cbloomrants.blogspot.com那个link中有伪代码.

但是好像windows上的Sleep() is a huge disaster, it's not exact.

(5) What is IMGUI?
https://mollyrocket.com/forums/viewforum.php?f=10
http://sol.gfxile.net/imgui/
http://sol.gfxile.net/files/Assembly07_IMGUI.pdf

Graphics Engine Architeture

2009-03-26T11:14:00.008+08:00

2009-03-26

1. when i was trying to implement one paper and see how it work, most of the time, i use glut. Actually, the framework with trackball function in Meshcourse07 and Nvidia OpenGL SDK 10.5 is good enough to meet my this simple need.

2. 但是当设计的模块多了之后，之前简单的在一个framework中mix了数据和显示这方面会显得极为混乱.
例如有一个Bezier Curves class, only deal with the data and operators cared by the curve itself.
还有一个是复杂显示的RenderDevice class, wrapper for opengl commands and rendering engine.
为了做到两者可以互不相关，
需要提供一个中间的协调者:
#include "BezierCurve"
#include "RenderDevice"
class Whatever {
BezierCurve *;
render(RenderDevice *) {}
controlBezier(UserInput *) { // call the functions fo BezierCurves }
...
};

3. 更复杂的还设计GUI widgets模块，windows窗口模块等，这些还需要继续了解。现在正在看G3D graphics engine的实现.

> 09-04-17

1. The first is "Essential mathematics for games and interactive applications".

2. The second one is related to the "Wild Magic Game Engine", the third 貌似不是关于技术的，虽然其作者的 G3D Graphic Engine 很吸引。

>2009-5-29 OpenGL Windows GUI Application MVC框架，multi-thread, 结合opengl来讲，很好。But, still call the gl command in the Model part, what to do is the data in the Model needed to be render ?

有用的文章链接

2009-03-23T22:29:00.004+08:00

Better, smaller and faster random number generator

Using Namespaces Properly 减少namespace冲突的几率.
C++ Without Memory Errors :garbage collection, reference count, small pointer.
Smart Pointer Thread Safety

Minimum Distance between a Point and a Line
Minimum Distance between a Point and a Plane

Some thoughts on the compute shader and the future So what's separating a GPU from a CPU? The difference is in how it approaches long latency operations, in particular memory accesses. Cpu use a large mount of caches, while Gpu use multi-thread. what is a thread is Gpu? ....

Gaussian Blur Experiments
Fixing Pathfinding Once and For All

Curve Bezier Patch, Tessellation

2009-03-05T21:29:00.004+08:00

Main Point is:
输入: 给出一个初始的原始网格(一般是比较coarse的啦，否则就没有必要进行tessellation了)。
过程：微观上，对网格的中每一个面face(可能是triangle or quad)，生成一个对应的控制面片，宏观上，这个原始网格就得到一个对应的控制网格了。
输出：上面生成的控制网格，要是看做是control points for bezier patches, then 给出参数坐标(u,v)不就对应于bezier patch上的某一个点了吗？整个控制网格得到的整个bezier曲面因此起到逼近approximate一开始作为输入的那个原始网格的效果。

难点在于怎么求控制网格/控制点，使得最好的patches直接能smooth, C1/G1。以及跟新的gpu pileline结合起来。

PN Triangles:

实现上本来很简单，但是我之前竟然弄了个很严重的错误，就是先求了原是网格的Loop limit surface再对这求PN。得到的PN triangle应该是interpolate原始网格的。
Reference：A.Vlachos, J.Peters, etc. Curved PN Triangles, 2001.
之后的工作还包括：怎么改善连续性，怎么加入sharp features，怎么扩展到triangle-quads等。详细的内容请google。

Tamy Boubekeur 的主页上继Scalar tagged PN, QAS, Subdivision Shading, Phong Tessellation之后又有新东西了，Realtime tessellation, 好像是他在这方面工作的一个总结，期待当中。
update 2009-05-10, quadratic-approximation-of-subdivision

Approximate Subdivision Shading 这篇文章提供了三方面的信息。1. 评论Subdivision Shading工作, 2. 将Subdivision Shading的方法跟下面将要提到的ACC结合起来，文中没有说得太仔细，但是我估计是在得到ACC的geometry patch之后，再求geometry patch上每一个顶点的normal(其one-ring faces的normals的avarage), 不需要求tangent patch了当然，在对geometry patch做evaluation的时候，同时对其上面的normals也做相同的evaluation。3. to achieve watertight surfaces when using displacement maps。

C. Loop & S. Schaefer的Approximation Catmull-Clark Subdivision surfaces with Bicubic Patches[ACC], 2007/2008. 现在的确比上面提到的PN, QAS都要热，一方面是因为现在DirectX11上新加入的tessellation功能. C. Loop本来就在Ms工作，估计这个ACC工作本来就跟D11的开发相结合的。相关的连接(1).Tessellation of Displaced Subdivision Surfaces in DX11 (2).Siggraph 2008: Next-Generation Rendering of Subdivision Surfaces 。

ACC上面没有考虑到sharp features, 因此有了Real-time creased Approximatie subdivision surfaces,2009.
10 Fun Things to do with Tessellation Hardware tessellation这个new tool有什么好玩的功能呢? 看看这个文章啦:-)
[Mar 26,09 update]虽然比Nvidia慢，但是ATI/AMD终于就在HW上实现ACC了 "OpenGL Tessellation Samples", 看来ACC真的太hot了，刚下载了demo来编译运行, 可惜我的RV380(Radeon X600)不支持。另外，因为ACC的实现需要one-ring neighborhood的信息，而在GPU中怎么能看到一个primitive vertex/face的邻域信息呢，并且还是在pipeline的前段，在vertex unpacked之前?

http://www.cise.ufl.edu/research/SurfLab/pubs.shtml 其中一个做细分曲面做得最好的实验室，上面N多好papers。而其中就有1, Smooth surfaces from 4-sided facets 2008; 2. Fast Paralled construction of smooth surfaces for meshes with tri/quad/poly 2008等和就网格生成smooth的Bezier patches并用GPU加速相关的工作。

当然在Tessellation得到bezier patches之后，可以在上面使用normal mapping, displacement mapping等来加添显示效果。
另外这里涉及一个watertightness的问题，怎么样使得相邻的patches之间不出现缝隙，这个倒没有深究。

Unified subdiviaion schemes based on the Sqrt2 subdivision operator

2009-03-03T14:30:00.001+08:00

刚完成了相关的工作并submit了，希望有个好的结果啦。

我是January从Dr. Li那里接手这个工作的，当时刚完成了approximation of Loop subdivision surfaces的工作，开始时候怎么也看不懂，因为涉及到了box-spline，而我对b-spline也都一头雾水，去google这个什么box-spline，download下来的paper都是公式公式，唯一的收获还是“可惜自己不是数学系的”。但是也不想问老师，因为听老师说会上手得快很多，但是像吃饭，一口下去吞了也就吞了，什么味道都不知道呢。于是，一直拖到寒假，晚上在家里看看，推推导，画画图，慢慢竟然有点feel了。之后，就coding，一切都顺利，使得我以为也不着急。但是到了2月中旬，发现需要在3.1号之前搞定，马上进入crease features的处理，于是，意料之外的痛苦开始了……

two weeks以后，工作完了，文章submit了，虽然还是不知道什么是box-spline，但是貌似效果还不错的：

Main References:

1. on subdivision schemes generalizing uniform b-spline surfaces of arbitrary degree. J.Stam. 2001.

2. Composite sqrt2 subdivision surfaces. Guiqing Li and W. Ma. 2006/2007.

Laplacian Smoothing 拉普拉斯平滑

2008-09-17T15:37:00.002+08:00

Question: if I do laplacian smoothing to a model many many many times, what happen???

上面的图是对horse模型的不断平滑结果，结果是收敛为一点（这个图没有贴上来，上面的图已经足够看到这个trend了）！！！
Reference: Skeleton Extraction by Mesh Contraction. ACM TOC 2008.

"Laplacian Smoothing that moves vertices along their approximation curvature normal directions. Note that an unconstrained normal flow of the vertices would progressively smooth out all the details of the model and converge into a single point."

Interpolaton Loop Subdivision Surface

2008-09-17T10:07:00.001+08:00

mentor好像对此有兴趣，所以暑假实习期间我就实现了这个文章，效果如下，可惜当时没有跟用于插值的Butterfly subdivision做比较。

Reference:

Interpolation by geometric algorithm. Takashi Maekawa, etc. 2006.

Metaballs

2008-09-11T12:35:00.001+08:00

第一次听到这个概念是关于一个叫spore的游戏。

Gamedev近来有一片介绍metoball的文章 Exploring Metaballs and Isosurfaces in 2D

How to Draw Bezier, B spline, patch, or Subdivision Surface using OpenGL?

2008-08-21T12:50:00.000+08:00

Conception:
http://groups.csail.mit.edu/graphics/classes/6.837/F04/lectures/16_curves_surfaces.pdf
Explain what is Bezier, B-spline(=uniform cubic BSpline, 是rational的), NURBS(=Non-Uniform Rational BSpline). 直观地，只考虑4个顶点的，order = 4，degree = order -1 = 3，Bezier curve是插值头尾两个控制点的，而且每递增3个新控制点才新产生一段curve，之后两端curve的接缝点只是几何坐标值相等，但是切向tangent却不连续；相比之下，Bspline curve并不插值首位两个顶点，每递增1个新控制点就产生一段curve，前后两端curve连续并且切向一直。
Q(t) = GBT(t) = Geometry(4*1 vector of four control points) * Spline Basic (4*4 matrix) * Power Basic([t^3, t^2, t, 0]).
它很绚的作业在http://groups.csail.mit.edu/graphics/classes/6.837/F04/assignments/assignment8/

OpenGL FAQ, 19.010 How can I use OpenGL evaluators to create a B-spline surface?
OpenGL evaluators use a Bezier basis. To render a surface using any other basis, such as B-spline, you must convert your control points to a Bezier basis. The OpenGL Programming Guide, Chapter 12, lists a number of reference books that cover the math behind these conversions.

首先，OpenGL/glu使用的evaluater是直接提供Bezier curve/NURBS的支持，但是B-spline就没有啦。结果是，B-spline curve都要转成Bezier curve来画啦。可以参考E.Angel's curves.c这例子。

E. Angel, Interactive Computer Graphics , A Top-Down Approach with OpenGL, Third Edition Addison-Wesley Longman, 2003. 这书上有一个curves.c的可运行例子，可以画Bezier，b-spline 以及interpolation curve，不错的。OpenGL虽然内部只支持Bezier但是由于b-spline与Bezier相互间可以转换，因此，用户给出b-spline控制点要画cure时候，我们就求要画同样一段curve用Bezier控制点的话这些Bezier控制点的坐标是什么呢？求出这些Bezier控制点坐标之后，这段curve就可以用OpenGL的evaluater来画了。E.Angel's curves.c例子就是利用了同一段curve可以用Bezier控制点来得到，也可以用b-spline控制点来得到。

http://www.itee.uq.edu.au/~comp4201/Curves6.pdf
这个ppt(curve and surface in OpenGL)里面不是介绍曲线的数学表达式，而是实际上怎样用
glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, &newcpts[0][0]);
glMapGrid1f(30, 0.0, 1.0);
glEvalMesh1(GL_LINE, 0, 30);这些具体画curve的函数.

http://www.dgp.toronto.edu/~hertzman/stroke/
里面的代码是在painterly rendering papers to draw brush strokes in OpenGL，除了画Bezier和Bspline curve之后还有一些NPR的资料以及siggraph 02的course note。

Google Code, search Bspline.

OpenGL Transformation

2008-08-18T15:05:00.001+08:00

Modelview（Modeling and Viewing） Transformation:

“First of all, telling about the order of matrices in a matrix product is senseless as long as nothing was said about using either column or row vectors. OpenGL uses column vectors, while D3D uses row vectors.” 这是必须先明确的，OpenGL中 v_new = M * v_old, where M is 4*4, and v_new , v_old is 4*1.

仔细阅读红宝书第三章(http://www.glprogramming.com/red/chapter03.html)里面介绍了可以从两个角度来看待矩阵变换次序。

首先，OpenGL中维护一个C is current modelview matrix. All viewing and modeling transformations are represented as 4*4 matrices, 用M表示。之后无论是直接用glMultMatrix*() or transformation command(glT/R/S) 其实就是将变换矩阵M后乘当前的C矩阵得到C*M，
然后在v' = C*M*v.

利用红宝书中的例子:
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMultMatrixf(N); /* apply transformation N */
glMultMatrixf(M); /* apply transformation M */
glMultMatrixf(L); /* apply transformation L */
glBegin(GL_POINTS);
glVertex3f(v); /* draw transformed vertex v */
glEnd();
先将C设置I, C' = CNML, v' = C'v = INMLv.
这个理解一般没有异议，解决了code顺序与矩阵乘法次序概念上问题。
也就是说如果你都写好了code，叫我将矩阵写出来当然没有问题；反过来，你给出里NML，让我将code写出来，这也好办。
但是，从用户/写代码的人来看，当我需要将一个object/vertex怎么变怎么变，又不知道具体的矩阵M，我怎么做呢？

关键要理解glTranslate*, and glRotate*的次序，红宝书中那先旋转还是先平移的例子要好好看。

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMultMatrixf(T); /* translation */
glMultMatrixf(R); /* rotation */
draw_the_object();

1. "fixed coordinate system - in which matrix multiplications affect the position, orientation, and scaling of your model - you have to think of the multiplications as occurring in the opposite order from how they appear in the code. "
从一个固定的全局的，可以理解为世界坐标来看的话，代码从后往前考虑，NMLv是L, M, N依次作用于v。这个"your model"为什么呢？书中的意思是从固定的这坐标系来看待时候，不要考虑你的物体坐标，反正我就是影响你这个物体的每一个点在我这个固定坐标里面的位置。
上面例子从固定的世界坐标来看的话，物体先被绕着固定世界坐标系的原点旋转，再沿着世界坐标系来平移，根本不用考虑什么物体坐标系。

2. “Another way to view matrix multiplications is to forget about a grand, fixed coordinate system in which your model is transformed and instead imagine that a local coordinate system is tied to the object you're drawing. All operations occur relative to this changing coordinate system. With this approach, the matrix multiplications now appear in the natural order in the code. (Regardless of which analogy you're using, the code is the same, but how you think about it differs.) ”
从物体的局部坐标系来看，有一个物体本身的坐标系跟物体本身绑定在一起，所有变换都会作用于这个物体的坐标系(同时由于物体是对于这个自己的坐标系来说的，所以物体跟着自己局部坐标系也被变换了)。
于是上面的例子中，物体的坐标系先被平移了，然后物体的坐标系绕着自己的原点来旋转。整个过程当中，世界坐标依然没有变，而且物体一直跟着自己的物体坐标系变化。对于想树形结构的物体，如机械人，太阳系，红宝书的建议是从局部坐标来看。

========
上面的问题弄清楚就看为什么人家常说要先做scale, then rotate, translate last呢？
v' = T*R*S*v
从全局的角度来看（也就是从后往前看），先做scale的话，scale之后的3个轴还是与scale之前的方向一样，虽然长度变了，但这不影响下面的Rotation变换。
从局部物体角度来看（也就是从前往后看），物体本身的坐标先做旋转，物体也跟着旋转了，之后的缩放，物体的坐标系会被缩放，连带物体也一样。

========

注意：
glRotate*(angle, xAxis, yAxis, zAxis), 其中轴(xAxis, yAxis, zAxis)是通过original的unit vector。

http://csc.csudh.edu/jhan/Fall2006/csc461/CourseNotes/CSC461-Lecture16.ppt
http://www.juniata.edu/faculty/rhodes/graphics/opengltrans.htm
http://www.cs.unm.edu/~angel/CS433/LECTURES/CS433_13.pdf 上面三个链接其内容几乎一样的，看这个就可以了。

http://pages.cs.wisc.edu/~psilord/docs/local_axis.html 难懂
http://www.songho.ca/opengl/gl_transform.html OpenGL Transformation. 从math上介绍geometry pipline上的变换矩阵，很好.

OpenGL, GLSL Tutorial

2008-08-18T14:22:00.004+08:00

Immediate mode -> VBO
Light, Texture -> shader
-------------------------------------------------------------------------------
OpenGL tutorial
红宝书,
http://www.codecolony.de/ 一些入门的例子。

GLSL
橙色书 OpenGL Shading Language 最快最明了的学习资料,
http://www.opengl.org/sdk/docs/tutorials/TyphoonLabs/ PDF文档。
http://nehe.gamedev.net/data/articles/article.asp?article=21 NEHE21课对glsl的基本概念简介。
http://www.clockworkcoders.com/oglsl/tutorials.html 入门例子, 里面有一个libglsl的库帮助使用glsl，看来这是趋势，这样就没有必要每次都自己来compile和link那shader了。
http://appsrv.cse.cuhk.edu.hk/~ymxie/Geometry_Shader/ 几何shader的简介。
http://cirl.missouri.edu/gpu/ 一个几何shander的例子。

Tools， Shader Maker
http://cg.in.tu-clausthal.de/publications.shtml#shader_maker
（里面还有些有趣的论文）。
(1)这个工具很适合入门，它将shader的载入编译以及链接都集成了，用户只需要将网上的vertex /geometry/fragment shader直接黏贴上前，F5就可以看到效果啦。
(2)被作用于shader的mesh是可以从外部载入的，虽然它本身提供了如cube,sphere, torus这里经典模型。这样的好处是，我自己的mesh processing算法对mesh处理之后，放入这里，然后从网上找些shader，就可以看到一些比较不错的render效果了:-)

NVIDIA
http://developer.nvidia.com/object/sdk_home.html
nvMath, nvImage, nvModel, nvWidgets,
使用GLEW, png & zlib, 怎么使用nv对gl的extension，
有一个uvShaderUtils.h来帮助使用GLSL.
实现了旋转，缩放，移动模型的操作。
======================

Vectex Buffer Object

2008-08-18T14:18:00.002+08:00

红宝书中有一节关于"缓冲区对象中的顶点数组"。

OpenGL VBOs specification. VBO is based on the vertex array(which has three steps:enable/define/draw array). 将array data放到server side, 并可以通过mapping得到buffer object的指针进而修改server side那边的data. 最后带有Usage Examples.

http://www.spec.org/gwpg/gpc.static/vbo_whitepaper.html

“VBOs are intended to enhance the capabilities of OpenGL by providing many of the benefits of immediate mode, display lists and vertex arrays, while avoiding some of the limitations. ”

http://developer.nvidia.com/object/using_VBOs.html

Reading. About GPUs.

2008-07-26T22:27:00.000+08:00

1. How GPUs work. David Luebke(Nvidia research), Greg Humphreys(University of Virginia)
http://www.cs.virginia.edu/~gfx/papers/paper.php?paper_id=59
其中D.Luebke名字挺熟悉的，查查看原来是A Developer's Survey of Polygonal Simplification Algorithms的作者:-)
他的blog上说"On July 24, 2006 I left academia to help start a research group at NVIDIA Corporation", 然后我再看看他的papers介绍，原来他是以做simplification开始的，在Lod方向也许多工作，之后是rendering以及gpu。从academia到corporation，之前的H.Hoppe加入MS也是，没有记错的话做细分的D.zorin加入Pixar....都是idol啊

2. how gpu works.
 http://c0de517e.blogspot.com/2008/04/gpu-part-1.html
 http://c0de517e.blogspot.com/2008/04/how-gpu-works-part-2.html
 http://c0de517e.blogspot.com/2008/04/how-gpu-works-part-3.html
作者的另一个文章http://c0de517e.blogspot.com/2008/06/begin-here.html也是很好的:
do it for fun.
Don't EVER think to know enough. You don't. If you've been programming for 4-5 years and took a 5 years university course, then you will have just the basics that are required to be able to understand almost anything, with some effort. They give you only the alphabet, from there on, there is the real knowledge! That's the single most important advice I can give you.

最后，要是哪位朋友有下面的书，不知是否可以借阅:-)
Geometric Algebra for Computer Science: An Object-Oriented Approach to Geometry (The Morgan Kaufmann Series in Computer Graphics) (Hardcover)by Leo Dorst (Author), Daniel Fontijne (Author), Stephen Mann (Author)
Real-Time Collision Detection (The Morgan Kaufmann Series in Interactive 3-D Technology) (Hardcover)by Christer Ericson (Author)

Problem. Evaluation of Hoppe94 Loop Subdivision Surfaces

2008-04-27T22:26:00.000+08:00

Given a point P(k, v, w) in the initial control mesh, where k is the triangle index, (v, w) is the corresponding barycentric coordiants(u+v+w=1). What is it posiition on the limint surface?

Papers give use the answer:
[1] J.Stam. Exact evaluation of catmull-clark subdivision surfaces at arbitrary parameter values. 1998.
[2] J.Stam. Evaluation of Loop Subdivision Surfaces.
I have implemented the [2], which is a trivial job, for most data (I use the lpdata50Nt.dat) can be downloaded from J.Stam's webpage.
However, if the loop masks are changed, for example, the h.hoppe97, then Stam98's evaluation method and data can not be used directly, because he did not take the feature types into consideration. So.... a big question, i'm still strugglling with it:-)
[3] Denis Zorin.Evaluation of Piecewise Smooth Subdivision Surfaces.2002

Hoppe 1994. Improved Loop Subdivision

2008-04-27T22:23:00.000+08:00

经典的Loop87版本，是对Box-Spline(这我也不懂)的扩展，是没有考虑feature type的。

H.Hoppe94版本的Loop模式在对顶点的特征类型进行分类基础上，对不同的顶点类型(smooth, dart, crease, corner)使用不同的masks。

Paper reading: Mesh Deformation

2008-04-16T22:22:00.000+08:00

现在我自己的工作倒是和mesh deformation没有关系，我在做subdivision surface fitting。However，montor好像有意在这方面做点东西，于是，我也偶尔看点这方面的paper。现在我希望有时间简略整理一下自己看过的，或者有点感觉的东西。
1. Multiresolution deformation
多分率，细节保持的变形。在某一层的变形基础上加上细节。怎么表示细节是一个问题。最简单的就是每一个顶点加一个法相位移。这方面的工作在2000左右热。可以看normal meshes, displace subdivision surfaces，这都是模型的另一种表示方式。
2. Laplace deformation
细节保持的变形，是基于微分空间的变形，就是在微分空间中表示变形。这方面类似的还有gradiant 能量函数，和possion能量函数这些变形方法。siggraph2004热的。
3. Deformation transfor
Deformation transfer for triangle meshes_sig04.Robert W.Sumner
将A模型的变化，转移到B模型，使得B模型也发生类似于A模型的变化。

Mesh Parameterization

2008-04-05T22:16:00.000+08:00

网格参数化的分类。根据base domain是否是平面可以分为平面的参数化和非平面的参数化方法。
而平面参数化方法，被参数化的网格必须有边界，进一步根据其边界在参数化时候是固定的还是自由的，分为固定边界方法和自由边界方法。具体的细节可以参考2007年siggraph course note的相关文章。

而我现在实现是Lee98的MAPS方法，将原网格一步一步递进的参数化都一个3D的base domain上。这个base domain是对origianl mesh的simplification的结果。现在的问题是怎么保证参数化结果里面没有triangle 的flipping和reduce 参数化的distortion。

Reference:
Lee98. MAPS: Multiresolution Adaptive Parameterization of Surfaces.

Vertex Hierarchy & Truly selective refinement of Progressive meshes

2007-12-15T22:12:00.002+08:00

Vertex hierarchy

所谓的vertex hierarchy就是一个由Node节点组成的forest，这个森林在简化时候建立，森林里面有N课树。
每一棵树的root代表一个简化最后的base mesh上的一个vertex，而它的所有leaf notes都表示形成root note是从哪些vertices来的。也就是说一棵树的节点表示了root节点是怎么形成的，一个树就记录了简化的细节。从一个parent note向下分裂成两个child notes就是vertex split过程，而从两个child notes向上形成一个parent note就是一个halfedge collapse的过程！
vertex hierarchy的结构和简化的过程密切相关，简化过程之后选择的半边的次序不一样的话，最后形成的vertex hierarchy当然也不一样。一旦简化结束之后，这个相应的vertex hierarchy也就是构建完毕了。此后，这个vertex hierarchy可以供selective refinement使用，方便地形成各个level下的mesh，和多分辨率有关系。

Truly selective refinement of Progressive meshes

目的：为了能够任意选择当前level下的一个顶点进行vsplit操作，而且每次vsplit只增加一个顶点。
将原来的PM结构中使用的两个关键的原子操作ecol(vs, vt, vu, vl, vr)和vsplit(vs, vt, vu, vl, vr)，改为ecol(vs, vt, vu, vl^, vr^)和vsplit(vs, vt, vu, vl^, vr^).
其中vl^和vr^是original mesh上的原始顶点, 而vl = active ancestor(vl^), vr = active ancestor(vr^). 这个active ancestor的函数是关键，但其实就在vertex hierarchy中体现了！要找一个节点的当前有效的祖先，只需要从这个节点出发，往上找它的当前有效的父节点就可以了。所谓的“当前有效”，也就是在当前这个分辨率中，在这个level中。

Reference:
[1]Garland97, QEM
[2]Kim, Lee 2001. Truly selective refinement of progressive meshes.

Quadric Error Metric (QEM), Preserving Boundaries -网格简化

2007-11-24T21:47:00.002+08:00

Garland97的论文中提到为了保护边界在简化的过程当中能尽量幸免，在计算每一个顶点的quadric的时候，是将边界面F沿其边界边e生成一个垂直面，这个垂直面的quadric也加入到e的两个端点的quadric中。详细请看原文的第六节。
下图是我对一个平面过简化效果图：

左图是1089个顶点的原图, 中间是没有加入preserving boundaries控制的100个点的简化图，第三图加入控制后的100个点的简化图，第四图是加入控制后简化为4个顶点的图。
其实加入垂直面的意义是使得边界点更趋向于往尽量成一条直线上的边界点做收缩。也就是说这将要被收缩的两个边界点所在的各自直线（这两直线当然是相连的）尽量不要成90度。因为90度的时候，点到垂直面的距离最大，收缩代价最大（这就是quadric的意义）。
> 2007.12.01
从上面的简化图中，可以看出有些三角形是发生了overlapping，后来加入的防止方法是检测一邻域里面的面的normal的方向的变化，如果变化例如大于90度就当作翻转。

"Mean Saliency", siggraph2005的论文

2007-11-12T23:39:00.001+08:00

下面左边是mesh saliency化, 右边是的mean curvature颜色化

"Mean Saliency", siggraph2005的论文。

概述
将Image中找寻关键部位的概念引入了3D的mesh。所谓关键部位，是指容易吸引人注意力的地方，也许更准确的说是特征部位。在image中，那些部位是shape和lighting的function，而在mesh中，暂时只考虑geometry/shape。
那么怎么表示mesh中哪些顶点是特征的是关键的呢？它是给每一个顶点一个标量值，也就是saliency(vi)。值大的表示这个点“突出”，值小的表示这个点“一般”。举个例子，一个球形的mesh，其surface上的所有顶点的saliency值都是一样的。

怎么求顶点的saliency值
论文中给出的算法是：首先假设是在scale 1下，这时，参数sigma_1 = 2 * epsilon, epsilon = 0.3% * 模型的bounding box的对角线长度。
1.求出每一个顶点的mean curvature，这些标量值是不变的了。2. 求出每一个顶点在sigma_1下的gaussion-weighted average mean curvature，G(vi, sigma_1)。这个公式详细请看论文。其中有个注意的地方是，使用都了当前顶点两倍sigma_1距离之内的邻居顶点。然后再求出G(vi, 2*sigma_1)。3。求出每一个顶点的saliency值，saliency(vi) = abs(G(vi, sigma_1) - G(vi, 2*sigma_1)).
将上面的过程重复5次，也就是scale 1, scale 2, scale 3, scale 4 , scale 5这论文中所谓的multi-scales。其中，scale 2时，sigma_2 = 3 * epsion; scale 3: sigma_3 = 4 * epsilon; scale 4: sigma_4 = 5 * epsilon.
最后一步是将每一个顶带你在5个scales下的saliency值做非线性的求和。具体公式也请看论文。

应用
其中一个应用就是改进Quadric error metric （QEM）简化算法。在每一个顶点的quadrc上乘以自己的saliency值，当然了这个saliency值已经过放大的。这其中体现了：saliency值大的顶点，更能表现重要性，应该在更后面被收缩。这和quadric(vi)值大的顶点推后被收缩是一致的。

Laplacian Operators

2007-11-09T23:32:00.002+08:00

一般遇到的laplacian operators有两个：
(1).[Taubin 95] "A Signal Processing Approach to Fair Surfac Design"中提出的Uniform Laplacian, also known as Tuttle Laplacian.使用的就是uniform weighted,将邻域顶点的坐标加和再平均。这是最简单的拉普拉斯算子。
(2) [Desbrun 99] "implicit fairing of irregular meshes using diffusion and curvature flow"中提出的Cotangent Laplacian. 使用的正是常说的Cotangent weight.

Laplacian Coordinate将一个laplacian operator应用到一个vertex就获得这个vertex的laplacian coordiante(这是一个向量),而这个laplacian operator的系数, 也就是the so-called laplacian coefficients.我的感觉是：某个vertex上的laplacian值反映了这个顶点于其邻域(neighborhood vertices)的关系。PS. 所谓的邻域，常见的为一个顶点的one-ring neigborhood.

我所come across的应用：
(1)利用Cotangent weight求Discrete Mean Curvature Normal of a vertex(这也是一个向量值)。H(vi) = (1/Area(vi) * [laplacian coordinate(vi)]；其的大小(标量值)就是某个顶点的mean curvature.这好像是反应了mesh model的固有特征。通过求解model中的顶点mean curvature值，可以直观的看到这个model的光顺性(这是我以为的,现不知对否）。在许多论文中，提到Laplacian operator的时候都常提到Mean Curvature.
(2)Laplacian smoothing常说的平滑smoothing可能包括了denoise and fairing两种。我暂时取狭义的denoise为smoothing。Laplacian smoothing：the classical Laplacian smoothing, where every new vertex of the meshis moved to the barycenter of its neighbors.vertex_new_position(vi) = vertex_old_position(vi) + laplacian_normal(vi);
(3)laplacian surface editting[O.Sorkine 2004].其实我正是看此paper的时候才开始认真查阅laplacian的信息的。当中拟合surface editting前后的laplacian coordiante of vertices来达到目的。可惜自己理解不够。

Progressive Mesh

2007-09-24T21:45:00.001+08:00

刚完成了使用了OpenMesh library完成了Progressive Mesh的写出，明天要完成对其的重新读入。
有兴趣的可以讨论一下。
---------------------------------------
2007-11-12
Hoppe论文中是使用最小化energy来简化mesh的，而我很惭愧地至今没有对mesh上energy的conception有清晰的理解，所以我是通过QEM算法来简化得到PM结构的。
但是我还希望能做到在PM结构上进行任意点的truely select refinement。在2001年的一paper"Truly selective refinement Of Progressive Meshes"中，似乎证明了对任意点的selective refine是可以进行的。当中引入了两个concept，dual piece of a vertex 以及 cut vertex of Vs。从中，我对QEM中的edge contract简化过程有个一个新的理解，整个simplification process中，其实就是mesh中某些三角形的扩张过程！扩张的结果？:-) think about it yourself

keep it simple

代码bug

顶点 边 面 数目的关系

三角面local frame上的tangent

两个向量的夹角

不同local frame之间的角度值

weekly update

三角形法向 - 两个frame之间的angle

叉积的方向

weekly update

Graphics memory size

Tech Coord

Weekly update 2010/9/6~

Weekly update 2010/8/23-29

add model list

Weekly update - 2010/8/16

Bug Series - angle between two vectors

Bug Series_Programing_link error_unresolved external symbol

Math Series - Cycloid 摆线 轮滚线

interesting stuff about geometry

To render the vertex

Thinking about Singleton

Math Series - Quadratic equation

Bug Series - 无效的int变成了有效的unsigned char

Bug Series - 数组变小了

ComboBox - model/view

Bug Series - crash at delete pointer

Gaussian Blur

How to locate the work item in OpenCL?

premultiplied alpha

Laplacian Mesh Processing

2010-3-9 有趣的东西-voxel sculptiing

2010-4-8 有趣的-有问题的

smart pointer 随想

问题-2010/3/31

SubD + Tessellator unit

why to learn OpenGL?

glext; glew, glee这些library的原理

opengl32.dll--Windows系统下OpenGL的实现和扩展

Reading note - memory management

intel relative

哲学 宗教

memory management in c/c++, resources

Apply Game Design as a Science?

Nvidia widgets (gui)

Graphics Engine Architeture

有用的文章链接

Curve Bezier Patch, Tessellation

Unified subdiviaion schemes based on the Sqrt2 subdivision operator

Laplacian Smoothing 拉普拉斯平滑

Interpolaton Loop Subdivision Surface

Metaballs

How to Draw Bezier, B spline, patch, or Subdivision Surface using OpenGL?

OpenGL Transformation

OpenGL, GLSL Tutorial

Vectex Buffer Object

Reading. About GPUs.

Problem. Evaluation of Hoppe94 Loop Subdivision Surfaces

Hoppe 1994. Improved Loop Subdivision

Paper reading: Mesh Deformation

Mesh Parameterization

Vertex Hierarchy & Truly selective refinement of Progressive meshes

Quadric Error Metric (QEM), Preserving Boundaries -网格简化

"Mean Saliency", siggraph2005的论文

Laplacian Operators

Progressive Mesh

顶点边面数目的关系

Math Series - Cycloid 摆线轮滚线

哲学宗教