CN1942896A - 用图形处理单元处理图形操作的系统和方法 - Google Patents

用图形处理单元处理图形操作的系统和方法 Download PDF

Info

Publication number
CN1942896A
CN1942896A CNA2005800114618A CN200580011461A CN1942896A CN 1942896 A CN1942896 A CN 1942896A CN A2005800114618 A CNA2005800114618 A CN A2005800114618A CN 200580011461 A CN200580011461 A CN 200580011461A CN 1942896 A CN1942896 A CN 1942896A
Authority
CN
China
Prior art keywords
class
default
impact damper
type
data
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Granted
Application number
CNA2005800114618A
Other languages
English (en)
Other versions
CN1942896B (zh
Inventor
马克·齐默
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Apple Inc
Original Assignee
Apple Computer Inc
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Priority claimed from US10/866,360 external-priority patent/US7248265B2/en
Application filed by Apple Computer Inc filed Critical Apple Computer Inc
Publication of CN1942896A publication Critical patent/CN1942896A/zh
Application granted granted Critical
Publication of CN1942896B publication Critical patent/CN1942896B/zh
Expired - Fee Related legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
    • G06T1/00—General purpose image data processing
    • G06T1/20—Processor architectures; Processor configuration, e.g. pipelining
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44—Arrangements for executing specific programs
    • G06F9/451—Execution arrangements for user interfaces

Abstract

所公开的是一种借助于图形处理单元和存储器来处理关于图像的多种数据结构的图形操作的系统和方法。所述系统和方法的所述公开技术创建用来累积对于数据结构的变化的数据结构的累积缓冲器。然后从累积缓冲器的数据结构的至少一部分创建分离的缓冲器。所述公开的技术借助于图形处理单元从分离的缓冲器读取数据结构。图形处理单元借助于操作影响从分离的缓冲器读取的数据结构。然后，所述公开的技术把操作的结果写到与分离的缓冲器相对应的累积缓冲器的所述部分上。

Description

用图形处理单元 处理图形操作的系统和方法
对相关申请的交叉引用
这是提交于2004年4月16日、并且标题为“用于图形操作的高级程序接口”的美国申请No.10/826,762的继续申请，该申请通过参考被全部包括。
背景技术
在过去几年，在所有各种硬件中对于图形子系统寄于的要求一直在增加。例如，在一般计算领域中，即使传统的大众程序，如表示软件，也包括要求更快和更复杂图形计算的动画和其它工具。另外，传统图形密集应用程序，像视频、图片编辑及游戏，在范围和图形密度方面都在增长。况且，垂直系统，如游戏和图形专用计算(例如，Nintendo Gamecube等)，为了图形优势甚至更快地加速与一般计算结构的竞争。
在此同一时段期间，硬件制造商已经寻求用具有日益增加能力的专用图形处理器来满足和超过增长需要。当今，有几种可买到的可编程图形处理单元(GPU)。尽管可编程和不可编程GPU都提供了用于图形计算的增强速度，但可编程GPU的不同在于它们提供高度灵活性。例如，在可编程GPU以前，应用程序程序员可能在使用CPU时间以呈现更有趣图形、或使用GPU增加整个应用程序性能但以显示较不理想的图形为代价之间权衡。可编程GPU已经把以前GPU的速度优点与显著灵活性程度相结合。在实用方面，可编程性是重要的优点，因为它允许程序以与系统微处理器类似的方式使用图形芯片。通过以这种方式使用GPU，系统可虚拟地产生无限图形效果而不加载系统CPU。
可编程GPU运行一般叫做分段程序的程序。“分段(fragment)”程序的名称来源于如下事实，运算的数据单位一般是象素-即图像的片段。GPU可在和几个象素上同时运行分段程序以创建结果，该结果一般通过它所驻留的缓冲器的名称被参考。GPU使用一般叫做纹理(texture)的数据输入，这种数据输入类似于象素的收集。
而且，在设想和开发GPU的同一时段期间，已经在进行为希望使用图形专用硬件的应用程序提供某些编程接口的努力。一种这样的努力通常称作OpenGL。OpenGL的目标是使得图形功能对于程序员是可访问的，其独立于硬件。在这样做时，OpenGL像状态机器。具体地说，使用OpenGL库的程序必须设置诸如当前颜色、亮暗、混合等等之类的状态。当程序被运行时，生成的上下文将是状态和输入纹理的组合，这样的组合取决于被编程的东西。给定状态机器类型操作，操作的结果不总是容易可预测的。
随着计算机向更加视觉丰富的内容迁移，图像处理变得更加重要。结果，程序员访问这些工具的容易性和图形计算的效率的重要性继续增加。尽管OpenGL和可编程GPU的组合已经提供了对于图形可编程性的广泛改进，但仍然有对于到图形子系统的更高级接口的需要。这种需要对于在图像处理中直接涉及的应用程序(例如，Photoshop、AfterEffects或类似软件)而加剧。在这些应用程序和其它程序中，希望有一个抽取层，其对采用该基础结构的那些人隐藏图形硬件的复杂性。此外，操作系统可能希望通过向所用应用程序呈现这样一个抽取层而有助于整体丰富用户图形体验。
这样一种接口应该允许程序员或程序简单地对于给定图像应用滤波器或效果。在对于更高级API的要求中隐含的是，以快速和高效方式实现该API的要求。为了高效，系统应该具有以容易理解和容易操作的方式概念化图形编程的机构。此外，这样一种系统应该使存储器和计算时间的使用的最小，同时也高效地划分在CPU与GPU之间的工作。最后，希望具有一种系统，该系统可以在单一处理器上仿真，从而为双处理器系统(GPU和CPU)建造的程序可在仅具有CPU的传统系统上运行。
除滤波器或效果之外，图形操作也是图像编辑的固有成分。图形操作(或更明确地说，累积图形操作)通常用在图像编辑中，该图像编辑包括画笔划、聚光、弯曲(warping)、渲染(caustics)、颗粒呈现(particle rendering)、或光线轨迹(ray tracing)。例如，用户可以把画笔划施加到图像上。另外，用户可以使用多个光源产生舞台状表现，并且把戏剧添加到他们正在编辑的图像上。图像弯曲也是对于可得到的一种有用的累积图形操作，并且是用户应用于图像的较流行操作之一。用于进行在CPU上实现的累积图形操作的当前技术可能使用多于所希望的更多处理和存储器空间。另外，各种累积图形操作涉及在复杂数据结构中的数据，如高密度限定定义颜色(光)、向量偏移、及图元球字段(metaball field)值。在这些复杂数据结构中的数据适合于由GPU计算。简短地说，GPU能以显著高的处理速度和以足够的精度进行这样的累积图形操作。因此，存在对于用GPU进行累积图形操作的需要。然而，GPU不能对于相同缓冲器进行排他性的读取/修改/写入序列，这妨碍GPU处理这样的累积图形操作。
本公开主题的目的在于，克服、或至少减小以上叙述的问题的一个多个的影响。
发明内容
在其它进步中，本发明寻求解决问题，并且满足上述的需要和希望。在这样做时，本发明的一些实施例包括用于图形操作、或潜在其它操作的高级程序接口，这些潜在其它操作可能采用辅助处理器资源。在这种类型的更具体实施例中，高级程序接口包括由用户或在系统中的程序可以调用的图形滤波功能。程序或用户通过由预定义列表创建效果或规定滤波器功能，而利用所述高级程序接口。在可选择实施例中，程序员或程序可以获得对于可扩展基础结构的访问，以把滤波器添加到所述预定义列表上。
在本发明的一个一般实施例中，软件将利用系统中的被选择的处理器，以编译图像任务的图形状描述。图形状描述可以是图像的节点和链接表示，其中节点可以代表操作员，并且链接可以代表中间结果和保持这些结果所必需的存储。更具体地说，在图形状描述中的节点可以最终包括线程或程序，用来在另一个处理器上计算整个图像操作的一部分。此外，具有整个图像任务的图形状描述，这允许优化编译器的使用，以减少用于整个图像任务的必要资源。这种编译功能特别有用，因为节点程序一般在不同于运行所述编译器的处理器的一个处理器上运行。
以上一般实施例可以在单一CPU与单一GPU临时配对的上下文中描述。这个实施例提出在CPU上运行的软件，以访问整个图像任务和构造其图形状描述。这可以视觉地表现为具有上述联系的节点和链接的树图。由于节点-程序可以在GPU上执行，所以程序的构造说明GPU的性质。最值得注意的是，并且在一般意义上，可编程GPU操作几个并行执行流，所以节点-程序可以以可并行化的语言表达。例如，节点程序可以是GPU分段程序。在代表整个图像任务的图形的建造之后，图形可以凭借在CPU上运行的编译器而优化。可替换地，当创建所述图形时，所述图形可以由编译器以不同的片段来优化。优化的目的是使存储器使用和CPU或GPU时间最小，否则当计算图像时获得效率。
根据本发明的变形实施例，优化可以具有多种功能特性。例如，优化可以包括高速缓存中间结果、把多个分段程序统一成一个、把存储器和计算限制到在定义的约束域和感兴趣区内的区域、或优化在处理器之间计算的划分。
在当今图形上下文中应用这些技术是高度高效的，并且允许开发人员通过表达将要在元素(例如，象素)上的进行的操作而写滤波器，而不用担心在系统中的特定硬件-它将由编译程序考虑。另外，已经创建了为了在多处理器系统中使用的API和高效处理基础结构，多个实施例也包括在单一处理器系统上利用API的功能。在非常一般的意义上，这通过仿真完成。
附图说明
图1是样本硬件配置。
图2(a)和2(b)是硬件配置的样本。
图3(a)和3(b)说明软件堆栈。
图4是图形。
图5是图形和样本程序步骤。
图6是图形。
图7说明用于图像创建的流程图。
图8说明用于节点组合的流程图。
图9说明用于节点组合的流程图。
图10说明用于节点组合的流程图。
图11(a)是图形。
图11(b)说明用于图形优化的流程图。
图12说明用于图形优化的流程图。
图13说明用于优化的流程图。
图14说明用于图形优化的流程图。
图15(a)和15(b)是使用多个处理器施加多种效果的说明。
图15(c)是使用多个处理器施加多种效果的说明
图16说明用于优化的流程图。
图17(a)和17(b)是多边形划分的例子。
图18示意表明借助于在CPU上的程序来处理累积图形操作的第一技术。
图19示意表明借助于在GPU上的分段程序来处理累积图形操作的第二技术。
图20表明借助于在GPU上的分段程序来处理画笔划的典型步骤。
具体实施方式
A.技术和术语
1.技术
这里描述的本发明实施例可能有在所有类型的多处理器计算系统中的暗示和使用，尤其是，其中不同类型的处理器用在一个系统中。这里讨论的大部分集中在具有CPU资源和GPU资源的普通计算构造上。所述讨论仅为了说明，并且不打算把本发明的应用局限于具有如下诸项的其它系统：没有GPU、多个CPU和一个GPU、多个GPU和一个CPU、或多个GPU和多个CPU。借助于声明，我们将提供关于典型硬件和软件操作环境的信息。
参照图1，表示普通硬件计算配置。非常一般地，微处理器11联接到芯片组支撑集成电路13和17上。微处理器可以是任何微处理器或控制器，如Intel Pentium族或IMB/Motoroal PowerPC芯片之一，如23、24或25。芯片组(这里表示为North Bridge 13和South Bridge17)可以在一个或多个IC中实现。芯片组13、17一般通过总线12或通过直接链接联接到所述微处理器上，所述直接链接在此时的技术中是熟知的。如果芯片组13、17在多于一个IC中实现，则通常是，North Bridge功能(AGP，存储器管理等)通过到共用总线的连接或上述链接而具有到所述处理器的更直接连接。包含South Bridge功能的分离芯片通过North Bridge非常共同地联接到微处理器11上。然而，我们不希望排除现在存在或将来可能存在的其它构造。某些潜在South Bridge功能包括用于诸如盘驱动器之类的外围附件的ATA总线16；用于所有形式外围装置的附加的PCI总线18；用于USB装置的附加的USB控制器19；用来支持以太网或潜在其它网络的网络接口控制器110；及声频支持111。更确切地说，典型North Bridge功能性包括存储器控制器，以支持主存储器114和加速图形端口15，用于支持视频子系统。存储器典型地是各种类型的动态随机存取存储器的任一种，但在可选择构造中也可以是静态RAM、磁性存储器、光学存储器、或存在或将来可能存在的任何其它适当存储介质。AGP 15是放置在芯片组中的专用端口，从而图形子系统具有对诸如微处理器和主存储器之类的系统资源的快速访问。AGP有各种出现的优点，并且当然存在加速在核心资源与图形子系统之间的交互作用速度的其它方法。所述讨论不打算把使用限制于实现类似功能的任何具体方法。最后，图2表示替换的计算硬件配置24和25，其分别打算用于与24和25微处理器的松弛联系。
如以上提到的那样，这里公开的本发明的实施例包括软件。这样，我们将提供普通计算软件结构的描述，如在图3的层图中表达的那样。像我们的硬件例子，这些绝不打算是排除性的，而是说明性的。这对于层型图特别是这样，软件开发人员往往以稍有不同的方式表达该层型图。在这种情况下，我们从O/S内核开始表达诸层，所以我们已经省去低级软件和硬件。我们的注释一般打算隐含使用来自下面层的资源的层中表示的软件元素，并且把服务提供给上面的层。然而，在实际中，具体软件元素的所有元件不可能完全以这种方式行为。
借助于关于软件的这些请求，参照图3(a)，层31是O/S内核，它在高度保护的环境中提供核心O/S功能。在O/S内核上方，有层32O/S核心服务，该服务把功能服务扩展到以上的层，如盘和通信访问。层33插入在这里，以表示OpenGL库和类似资源的一般相对定位。层34是功能的混合，通常被表达为两个层：应用程序框架和应用程序服务。对于我们讨论目的，这两个层都为驻留在这里表示为35的最高层中的应用程序提供高级和经常的功能支持。条目C100打算表示“核心成像”、软件套件及moniker的相对定位，这提供用来描述当前发明的多个实施例的载体(当提到包括某些、任何或全部或本发明实施例的软件套件时，我们一般使用术语“核心成像”)。
现在参照图3(b)，条目101代表核心成像套件的相对定位。显然，通过比较图3(a)，已经添加324层用于另一种图形功能-合成(compositing)。合成器的工作是在视窗系统中进行窗口合成和管理，如对于多个实施例讨论的视窗系统。
2.树和图形
在数学和其它计算科学中，问题可以以分析样式表达，这有助于机器进行计算和这样的机器的编程。分析表达的例子是一般化树结构，如在图4中表示的那种。参照图4，树结构41包括：代表最近从属节点的结果的链接(42、43、44、45、46、47、48、49、410、411、412、413及414)；及两种类型的节点。有代表预先存在的计算输入的叶节点(例如，操作数)，419、424、425、426、427、428及429。可替换地，有代表计算功能(例如，算子)的功能节点415、416、417、418、420、421、422及423。作为整个例子，参照图4，链接46用作到功能节点417的输入，并且代表叶节点424的结果(叶节点的结果，简单地表示叶)。
现在参照图5，使用矩形节点(而不是圆圈)表示另一个树。然而，图的代表性本质相同：叶节点51类似于操作数；功能节点52、53、及54代表算子，及链接5100、5101、5102、5103及5104代表结果。
在本公开的各种位置处，我们使用像在图4和5中那些的树，并且我们在计算机系统内使用和汇编的“图形”的上下文中讨论那些树。我们一般不打算意味着，计算机系统构造或使用所画出的图形树，而是系统形成、保持或使用我们为人类说明目的画出的图形树的某种代表。
此外，我们一般在讨论图形技术和软件的上下文中使用树(或图形)。从应用程序和程序员的角度出发，由树或图形定义的图像通常与由象素阵列定义的图像是不可区分的。两种类型的图像定义同一最终对象，并且对象是应用程序与图像相关。在某些方面，关于核心成像(或这里实施本发明的其它软件)的前景同样如此。因此，核心成像通过估计图形可以估计图像计算任务。在这方面，图形的根节点的结果是最终结果。参照图4和5，节点415和54是图形的相应的根节点。
在描述本发明和核心成像的实施例时，我们常常提到这些示例性工具。因此，通过关于这里讨论的多个实施例的介绍，参照图4，如下联系在我们的讨论的上下文中是适当的：(i)所示的树一般指低级图形；(ii)功能节点415、416、417、418、420、421、422及423代表在诸如GPU之类的微处理器上运行的“内核”或分段程序；(iii)叶节点419、424、425、426、427、428及429一般代表图像，也就是，象素的集合或其表示；及(iv)链接42、43、44、45、46、47、48、49、410、411、412、413及414代表结果，尽管在实际将发生的操作的上下文中，这些结果通常与用来存储它们的缓冲器相联。
另外，为了关于这里讨论的实施例的多个的介绍目的，参照图5，如下联系在我们的讨论的上下文中是适当的：(i)所示的树一般指高级图形；叶节点51代表图像；功能节点52、53、及54代表高级滤波器，通常是预定义滤波器；及链接5100、5101、55102、5103及5104代表滤波器的结果，但不同于低级图形，不必与缓冲器相联。。
B.来自程序员观点的核心成像API
本发明的多个实施例涉及面向对象编程，并且形成对于程序员可得到的四种类型的对象。这些对象类型是图像、滤波器、上下文、及向量。简短地并且以不限制其一般性的讨论所述每一种。
图像是两维呈现结果(象素图像)，或者是其表示。在高级程序操作中，我们常常保持代表图像的对象，这些对象需要计算以成为实际象素值。本发明的不同实施例可能采用象素值图像和非计算图像之一或两者作为图像的定义。其具体意思从上下文使用很容易地导出(与“上下文”对象无关)。在一般意义上，在关于滤波器的讨论期间，图像应该解释为对于功能或滤波器的输入。
滤波器是用来影响图像的高级功能。滤波器可以包括在本公开的末尾列出的预定义滤波器的一个或多个。滤波器可以类似于分段程序，该分段程序类似地影响图像(或更精确地，通常是纹理)，然而，一次仅产生一个象素。在本发明实施例的多个中，核心成像编译基于滤波器的图像操作，从而在使用分段程序的GPU上可能出现这样的操作。在滤波器与分段程序之间不必有一一对应。
上下文是一空间，如在滤波操作的结果所驻留在其中的存储器中的定义区域。如果图像假定是如上建议的输入，那么上下文假定是输出。
向量是浮点数的集合。对于这里讨论的大多数实施例，向量与四个浮点数相关，每个数具有相同固定的位数-通常为32。在图形中，向量可以用来代表(i)描述象素外观要求的四个尺寸(R(红)；G(绿)；B(蓝)；及α(透明度))；或(ii)描述两维空间、三维空间、或四维空间(均匀)坐标：X、Y、Z、及W分别要求的两个维度或三个维度。
C.核心成像和核心成像API
核心成像是软件套件，该软件套件包括多种例行程序，并且尤其是如下功能，为图形功能建造但单独可应用于诸如数学(例如卷积运算)之类的其它功能的高级编程语言或API。记得，我们使用moniker核心成像指任意一个实施例或任意一组实施例，并且我们不打算把本发明限于关于“核心成像”的任何具体评述。类似地，我们可能提到如核心成像的例行程序或过程，或者在核心成像内，并且由此，我们不打算暗示这样的软件作为单个单元或层而实现。
核心成像包括用来与图形框架和图形集中应用程序服务套件通信的高级编程语言或API。这也包括用来由高级语言产生汇编的编译器。语言/API是独立的平台和硬件，因为图形框架和从属软件层可以说明平台或硬件差别。API允许程序员对于图像施加影响，而不用担心(1)由OpenGL等类似接口要求的状态和其它参数、或(2)用于进行图形呈现的GPU或其它资源的汇编语言。
当概念化为软件时，核心成像(或API和相关编译器的实施例)可以视作一般定位在应用程序与操作系统之间的图形服务例行程序套件。由于分层软件概念化受到变化的解释，所以这种讨论不打算排除其它方式来概念化核心成像(根据本发明的实施例的任何图形服务软件套件)的分层位置。基于上述声明，参照图3(a)和3(b)，分别表示图形服务软件套件3100和3101。
这些图形服务3100和3101的定位意味着，这些套件可以包括用于应用程序框架、应用程序服务及图形资源的元件。简短地说，这种定位的意图是意味着核心成像3100和3101可以与如下诸项交互作用：在层35和327中的应用程序；在层34和326中的其它框架或服务；在层33和325中的诸如OpenGL之类的资源；在层24中的合成器；及在层32和323中的O/S服务。
在一般意义上，如应用于图形那样，核心成像允许程序员和程序通过(1)使用预定义高级滤波器或(2)通过使用API或本发明的一个或多个其它实施例汇编一系列预定义滤波器，来起作用。在后一种情况下，程序员或程序对于用于预定义滤波器的零或更多的高级描述的核心成像进行API调用。程序员或程序把这些高级描述(或到其的参考)放置在我们将叫做高级图形的数据结构中。高级图形由创建新滤波器的程序员或程序汇编。高级图形定义在预定义滤波器与新滤波器中采用的图像之间的关系。当程序员或程序已经完成建造其高级图形时，它已经有效地完成其用来创建新滤波器的任务。就是说，创建新滤波器必需的所有信息在高级图形中体现。
在替换实施例中，当程序员或程序与核心成像合作汇编图形时，创建的图形可以是低级图形，或基本上是低级图形。例如，从程序员或程序角度出发，对于高级滤波器可以形成请求，然而，核心成像可以创建和输送对象，该对象是低级滤波器或在低级滤波器与高级滤波器之间的某一中间步骤。由于程序或程序员不实际检查对象，所以核心成像可借助于低级代码来响应对于高级代码的请求。以这种方式，核心成像可以汇编低级图形，而程序相信正在与高级滤波器和对象工作。
核心成像具有最终优化和编译高级图形(与任何可应用输入参数一起)以产生GPU-准备程序的额外任务。编译步骤可以仅在最终图像的使用时进行。总之，程序员或程序已经使用API(包括预定义滤波器)的高级语言以创建并影响，这基本上是包括各种其它滤波器和输入的新滤波器。程序员或程序员也可以编程地把这种滤波器应用于图像。本发明的各种实施例设想在GPU与CPU之间的工作的各种划分。一般地，CPU将运行核心成像，并且GPU将运行核心成像的最终产物。然而，依据硬件能力和最终优化，核心成像可以创建用于CPU和GPU的任务。此外，如果在系统中没有可编程GPU，则核心成像可以创建用于CPU的对象，以把图像变成上下文。
D.核心成像实施例的基本功能
现在在一个实施例中更充分地观看核心成像的能力，API为程序员和最终为应用程序的用户提供六种高级功能：上下文的创建；图像的创建；滤波器的创建；设置与滤波器相关的参数(例如，滤波器功能的参数)的能力；请求已汇编的滤波器或滤波器组的输出的能力；及把图像变成上下文的能力。
1.创建上下文
我们一般把输出当作上下文，所以创建上下文的能力从允许在存储器中定义对象的工具导出。这样一种对象的定义是必要的，从而可以有一个用于操作结果的目的地。例如，上下文可与在主存储器中的位图或与OpenGL视图相关。这些相关图像容器被用作目的地以用于呈现。尽管本发明主要设想存储器，如与系统的图形功能相关的视频存储器，但这里讨论的概念同样适用于在系统其它处找到的或对于系统可访问的任何存储器或存储区。因此，没有限制地，存储器可以包括所有类型的固态存储器，如动态存储器或静态存储器，不管其与图形子系统相关、与图形子系统共享、还是名义上专用于主系统、或由主系统可访问的另一个子系统。此外，尽管速度肯定是问题，但这里的概念不打算排除磁性或光学存储器。
作为创建上下文的例子，我们可假定，应用程序希望最终把某种东西显示到屏幕。假定Apple的iPhoto应用程序希望响应用户命令显示海岸的图像。iPhoto通过调用请求上下文的创建的功能而采用核心成像API。核心成像除其它可能东西之外将返回所创建的上下文的识别句柄。让我们假定句柄是“空上下文”。
2.创建图像
我们一般把输入当作图像，因为在图像中的坐标或象素可以取样以产生相关值。例如发明的API的实施例，图像可以无中生有、或由另一个图像创建。通过提供用来创建象素值的机构，图像可无中生有。例如，图像可以通过简单地把图像定义为颜色或颜色的数学组合(像检测板或条形页)，从而无中生有的创建。图像更普通地可以通过把一个或多个滤波器应用于存在图像而由另一个图像创建。
遵循来自以上的我们的iPhoto例子，iPhoto可以通过要求图形服务以把小孩的现有图像带到海岸上并且把滤波器(例如，模糊)应用于小孩外的某一区域而创建一图像。在这种滤波器的应用时，创建一个新图像。为了清楚起见，这是非计算图像，因为新象素值没有计算，而是，模糊滤波器已经编程地应用并且驻留，或者在图像缓冲器被参考，其中计算象素必需的所有其它元素或者被存储或者被参考。
3.创建滤波器
我们一般把滤波器当作在零或更多图像(最终象素)上可以进行的任何功能。稍微更具体地说，滤波器可以是接收图像和其它参数(与具体滤波器相关并且取决于该滤波器)作为输入并产生新图像的功能。API当前提供几十种滤波器，这些滤波器被列出并且在本公开的别处描述。然而，本发明的实施例需要可扩展性质，所以本发明人继续开发滤波器，并且也已经提供了开发滤波器的其它能力。尽管本发明设想允许预定义类型滤波器的添加的可扩展性，但我们的讨论将集中在由零或更多预定义滤波器的组合和操作所创建的新滤波器上。
对于程序员或程序，对于滤波器创建想到的一种方式是，通过使用发明的API的实施例，把一个或多个API的预滤波器和程序员希望应用的任何其它项目或功能捆在一起而开始。如早先提到的那样，为了创建新滤波器，程序员或程序可以创建高级图形，其包括所有图像的表示和将使用的预滤波器、和在那些对象之间的关系。在某些实施例中，预定义滤波器打算尽可能综合基本图形功能，以便使程序员或程序编写用于GPU的汇编的需要或动机最小。的确，核心成像的整体益处在于，在应用程序层处编程而不用参考专门图形硬件的能力。
一旦借助于高级图形定义新滤波器，应用程序或用户(在CPU级处)就可以调用核心成像以实现高级图形(在图形中参考的图像上，以由图形定义的方式实现在图形中参考的滤波器)。当然，高级图形可能已经写成包括多于一个图像，但技术是相同的。当实现滤波器时，核心成像可能要求其它的输入数据，因为滤波器共同地具有滤波器专用输入，如用于模糊的模糊半径、几何参数或任何其它输入，如在后文列出的滤波器中规定的那些。
核心成像的重要功能是然后把一个或多个对象返回到应用程序或用户。根据本发明的变化实施例，返回的对象可以被呈现，或为在GPU、CPU或这两个的某种组合上的计算做好准备，在一个替换实施例中，核心成像在响应对高级元素的应用程序请求的同时建造低级图形的全部或部分。在这个实施例中，应用程序相信它要求较高级代码，而核心成像正在输送低级代码(应用程序不能探测差别，因为它不分析由核心成像输送的对象)。可替换地，在优选实施例中，当应用程序要求在上下文中的图像时，返回对象可以是为适时(iust-in-time)编译准备的优化低级图形。在某些实施例中，核心成像将只返回一个对象，该对象要适时编译并且在GPU上运行。为了这样做，核心成像必须转换(并且一般优化)高级图形，并且把图像转换到纹理(GPU使用纹理，而不是图像用于计算)。在把图像转换到纹理时，核心成像使用CPU首先把图像转换到样板。样板是图像加上其状态，所以转换到样板包括并入状态信息的步骤，如下：(1)缠绕(wrap)模式，如透明、夹固或复制；(ii)内插模式，如使用从最近整个象素到主题象素的值，或跨过围绕主题象素的四个象素的栅格内插；及(iii)仿射(affine)变换，如转动、缩放、倾斜、平移、镜像。样板然后可以容易地转换到由GPU使用的纹理。以所有这些作为输入，运行核心成像的CPU创建包括GPU程序的对象，该GPU程序当执行时将在实际象素上实现滤波器(由以上创建的纹理提供)。
现在参照图5，我们将进行滤波器创建的一般例子。回想我们的iPhoto海岸例子，用户可能要求iPhoto自动增强图片。纯粹为了说明目的，假定自动增强要求如下滤波器创建。这纯粹是为了说明，因为当前iPhoto增强特征实际上不以这种方式操作。iPhoto将首先创建其希望滤波器。这个过程可以通过调用核心成像以分配基础图像51而开始，基础图像51在这时可以处于图形或象素形式。我们在图5的步骤一和高级图形树图中看到这个。其次iPhoto调用核心成像以添加程序步骤(和对应树位置)而把颜色校正滤波器52应用于图像51。我们在图5步骤2和高级图形树图中看到这个。注意，在图5中的步骤2的输出定义为Piaceholder(占位符)CC(用于颜色校正)海岸。由于在这时不确定这个中间结果(CC海岸)何时或者是否曾经存在，则我们不分配缓冲器，而是把占位符放置在指示中间结果的可能性的高级图形中。在自动增强特征的促进中，iPhoto可能还包括假色滤波器53应用于52滤波的结果。如以前那样，iPhoto将调用核心成像以获得高级假色滤波器并把它插入在安装高级图形(和用于说明目的的在图5中的树)中。然后，为了圆整自动增强功能，iPhoto可能选择借助于原始海岸图像(51)平均53滤波(FC CC海岸)的结果，所以适当滤波器54会由核心成像调用，并且插入在高级图形中。这在图5的树图和样本程序步骤中都看到。
在我们的例子中，iPhoto现在具有用于其自动增强海岸图像的希望结果的高级图形。为了使该结果按照这个例子的实施例可用，iPhoto可以顺序调用在核心成像中的例行程序(或者核心成像可以单独作用)，以转换、优化或编译高级程序，如以上描述的那样。为了说明目的，以简单形式表示的结果(类似于图5)显示在图6中。我们在图6中看到，分段程序(62、63及64)不必与包括用于在图5中表示的自动增强的高级树的高级预定义滤波器良好地类似。每个高级滤波器可以包括一个或多个分段程序，以实现其目的。此外，当程序被优化时，有可能分段程序被替换、重新排序或消除。最后我们看到，在图6中表示的GPU实施从纹理开始而不是从图像开始，并且通过把结果放置在实际位置中(缓冲器-不再是占位符)而结束。
4.设置用于滤波器的值
如早先提到的那样，每个高级滤波器，不管如以上创建的还是在这里的列表中预定义的，可以具有必要的并且由滤波器功能定义的一组输入值。在我们的海岸例子中，我们把这些输入参数表示为向量“参数(X、Y、Z、W)以代表通用输入(见图5)。另一个和较不通用的例子是模糊滤波器，该模糊滤波器几乎肯定地要求模糊半径作为输入参数。而其它例子是输入颜色、输入密度、输入饱和度等等(参见在上下文中用于更多例子的滤波器的列表)。用于核心成像的API必须为程序员和程序提供设置这些输出参数的能力，这允许图像的可预测创建或编辑。
参照我们的iPhoto海岸例子，我们对于我们的图片上的区域进行模糊。尽管准确的输入参数取决于特定模糊滤波器，但iPhoto大都可能需要供给模糊半径。
5.要求滤波器的输出
在一个实施例中，一旦图形对于具体滤波器存在，程序或程序员就可以调用用于该滤波器的输出的核心成像。作为响应，核心成像创建为适时编译准备的对象并且然后通常仅在GPU上的执行。高级滤波器的这种输出简单地是非计算或代表性图像。在可替换实施例中，核心成像可以优化所述图形或计算在该点处的图像。前一实施例常常是优选的，因为优化要求处理循环，并且计算将使用处理循环和存储器。这些资源通常最好被保留，直到我们确定图像必须呈现为上下文。
参照在通常较优选实施例(节省存储器和处理器时间)中我们的iPhoto例子，iPhoto将调用核心成像，以产生非计算的图像，为适时编译和执行准备好。
a.创建滤波器输出的声明
像多种图形处理引擎，核心成像或许可以建造成仅在一个颜色空间中操作，例如“光线性(light linear)”。因此，为了处理图形，某些实施例必须把颜色空间转换到光线性，并且在运行结果之前，必须把颜色空间转换回其原始颜色。在某些实施例中，这种转换通过在高级图形的输入和输出处放置适当的颜色转换高级滤波器而在高级图形上实现。在其它实施例中，这在低级图形上出现，但是以非常类似的方式。在低级图形的情况下，用于颜色转换的分段程序节点的“内核”放置在图形的输入和输出上。对于其中节点放置在图形(高级或低级)中的大多数实施例，该情形规定该颜色转换节点的结果在将来非常可能是有用的。因此，颜色转换节点的结果在大多数实施例中应该高速缓存。对于创建用于颜色转换的图形节点的一个替换例是把这样的转换编程为核心成像例行程序的一个。
6.把图像变成上下文
最终，大多数图像为诸如显示之类视觉用途而创建。因此，在这个图像创建实施例中的极普通步骤是要求图像变成某种定义上下文。对于大多数实施例，核心成像将在这时进行图形的优化。简短地说，优化可能涉及如下的任一个或全部：(1)产生低级图形，其中为了概念化目的，图形的节点代表分段程序，并且低级图形定义图像与分段程序之间的关系(这与包括图像和高级滤波器及它们的相互关系的高级图形相反)；(2)对于定义的域的优化；(3)对于感兴趣的区的优化；(4)组合分段程序以减小图形的尺寸，并且最终减小其执行将要求的存储器空间；及(5)把优化低级图形的执行要求与驻留硬件(GPU、CPU、存储器等等)相比较。一旦优化，就编译低级图形，并且产生一个或多个可执行对象。如我们已经讨论的那样，通常有用于GPU的一个可执行对象，然而，在优化或编译期间，可能确定应该采用多个处理器。在编译之后，执行所生成的对象，并且图像变成规定的上下文。
再次参考我们的iPhoto例子，为了把图像放在屏幕上，iPhoto将调用核心成像以把对象呈现到屏幕上。在典型的实施例中，这个步骤涉及在图像中的所有相关象素上运行并且产生增强图片图像的GPU代码。图像可以通过把它放置在与屏幕显示相关的缓冲器中而可以放置在屏幕上。
E.优化
优化是分析和改变程序或任务的过程，从而当实际执行任务时，它被最高效或容易地执行。在这里讨论的大多数实施例的上下文中，我们寻求使用一个微处理器以优化用于另一个微处理器程序代码。在更具体的实施例中，我们寻求使用系统CPU资源以优化要在GPU上运行的程序。在进一步具体的实施例中，CPU分析被表达为图形的图形任务(典型地把效果的应用程序于图像)，并且优化图形，从而当图形适时编译时，它在GPU上最高效地运行。
我们已经在一般和特定上下文中讨论了优化和编译。没有限制以前公开的范围，我们现在将讨论涉及用于优化的四种不同的一般技术的任何一种的核心成像的实施例。这四种一般技术是：中间结果的高速缓存；把计算和存储限制到定义的域；把计算和存储限制到感兴趣的区；及图形重写以减小或简化图形。
由于优化处理在如CPU周期、GPU周期及存储器空间之类的实际项目中的节省，所以我们通常参照我们已经介绍的最低级别(最接近硬件)概念说明工具来讨论优化技术。该工具是低级图形。然而这些技术不应该视作限于单一级别的概念化。的确，这些技术在说明性抽象的更高级和更低级下(例如，在更高级图形上或在编译代码上)可以应用和实现高效率。
所公开的优化技术当在各种顺序和甚至混合顺序中采用时可能是有用的，其中顺序的技术递归地一次应用于一个节点或图形的段。然而，为了是最清楚地说明性的，我们介绍在图7中所示的在逻辑顺序命令中的技术。现在参照图7，核心成像在步骤7100处从应用程序接收图形任务。对于任务在低级图形中还未实施的程度，在步骤7101中，核心成像必须创建低级图形。其次，在步骤7102中，核心成像进行节点减少分析，并且尽可能消除节点。在优化不必要的(或可分解的)节点之后，核心成像前进到步骤7103，其中进行优化以最终限制缓冲器的尺寸和图像输入。这个步骤涉及叫做定义域(“DOD”)和感兴趣区(“ROI”)的两个区。在ROI/DOD优化之后，图形准备在步骤7104中编译。最后，所有这些先前工作已经在CPU上运行，程序发送到GPU以便呈现(如我们已经始终讨论的那样，某些实施例也可以编译图形的部分，并且把其发送到CPU)。
在讨论上述优化技术中，可能存在在图形中的节点的实施例的较深理解中的使用。我们将相对于在低级图形中的节点说明，但所述概念应用于任何类似表示。至此，我们已经讨论了作为功能、滤波器及分段程序的节点。然而，为了实现对于图形的分析，我们要求具有更具体和更丰富信息的节点表示。因此，在本发明的变化实施例中，基于希望性和必要性，低级图形节点具有如下相关信息：(i)像已经讨论的分段程序之类的程序；(ii)用于程序的参数，可能包括样板(具有状态的图像)、和一个或多个向量(记住向量是浮点数的集合)；(iii)用于节点输出的定义域；及(iv)ROI功能，提供用于节点的输入形状的准确预测，给出输出形状(都在坐标系中定义的形状，或同一球坐标系)。
1.中间结果的高速缓存
为了对于同时计算所固有的原因，应用程序将一次接一次地频繁地要求相同或类似图像的计算。应用程序也常常要求是以前计算图像的子集和超集的图像的计算。为此原因，核心成像采用高速缓存技术以防止不必要的工作。在大多数实施例中，图形节点形成我们的用于高速缓冲存储器管理的基础。具体地说，回想我们已经讨论了高级图形，如由在图5中的树代表的高级图形。我们也已经提到可概念化为在图4和图6中表示的树的低级图形。对于某些实施例，我们假定在图形中的每个节点是不变的并且由在它下面的图形的部分所定义(即，求解节点要求的对象和计算)。已经进行该假设后，我们可高速缓存节点的结果(典型地为一图像)，并且然后确定同一节点(定义为它下面的图形之和)是否在待重新计算的队列中。取代重新计算节点，我们简单地从存储器提取结果。根据变化实施例，这可以对于所有节点进行。为了高效地使用存储器，我们可以选择在不同时间(例如，当存储器使用率较高时、或者当高速缓存的条目较旧时、或者当相关应用程序关闭时、或者当系统停止时)删除高速缓冲存储器。另外，为了存储器的高效使用，我们主要使用分配给视频子系统或GPU的静态或动态存储器。然而，我们可选择把这些高速缓冲存储器放置在任何可访问的存储区中，如系统存储器、硬驱动器或在系统中的其它磁性存储器或甚至可能的网络可访问存储区。
在可变实施例中，在优化期间(例如，在CPU上)、在呈现期间(例如，在GPU上)或两个时间期间，可以采用高速缓存。
2.图形重写以减少或简化图形
在本发明的某些实施例中采用的另一种高效率技术是通过消除不必要节点而优化图形。当成功时，这在其节省方面可能是深远的，因为它一般消除全部临时图像和对于缓冲器的相应需要。另外，合并或消除节点将在执行期间节省处理周期。
为了合并，核心成像必须求出可以减少的相邻节点对。一般地，如果一个节点的输出是第二个节点的输入，则两个节点可以减少成一个。例如，如果节点Alpha(α)的输出定义为Alpha Buffer(α缓冲器)，并且节点Beta(β)的输入是存储在α缓冲器中的纹理，那么两个节点可以组合。
就计算周期而论，确定两个节点是否可以组合可能是较昂贵的分析。因此，当进行关于两个节点是否可以组合的确定时，该确定可以被高速缓存。清楚地说，某些实施例高速缓存否定和肯定结果，所以程序可以使用高速缓冲存储器，以便不仅求出高速缓存的组合，而且确定组合是否不可能，从而不浪费进行分析的时间。示范实施例表示在图8中。在进行组合查询8100时，第一步骤8101确定对于这些节点的分析结果是否以前已经进行以及是否驻留在高速缓冲存储器中。因此，在步骤8101处，系统检查高速缓冲存储器的预分析组合结果。另外，由于我们讨论的例行程序典型地在CPU上运行，所以这个高速缓冲存储器将在多个实施例中使用系统存储器。最后，作为如何可以标记高速缓冲存储器的例子，在一个实施例中，高速缓冲存储器密钥具有四条数据：(1和2)两个节点程序的表示、(3)在上级节点程序中的纹理单元指数的表示，该程序接收来自下级节点程序的输出；及(4)规定输出值是否应该定位到范围0、1的Boolean值的表示。
返回步骤8101，在这个决定步骤处有三条可能路径。首先，结果可以被高速缓存，并且节点可以组合。在这种情况下，控制转到步骤8103，并且使用高速缓存的结果进行组合。控制然后转到步骤8104，以求出并且分析下个节点。第二，结果可以被高速缓存，但节点不可组合。在这种情况下，控制直接行进到下个节点步骤8104。第三，最后，结果可能不在高速缓冲存储器中。在这种情况下，控制转到步骤8102，以确定提出的节点的组合是否是可能。如由步骤8105指示的那样，不管组合是否可能，结果都被高速缓存(指示组合是不可能或组合是可能的，并且存储结果)。在步骤8012处，如果组合是可能的，则它在步骤8016处进行，尽管在实际中，某些实施例在分析期间进行组合。在进行组合之后，控制转到8104用于下个节点。最后，如果步骤8102确定组合是不可能的，那么控制转到8104用于下个节点。
3.用来组合两个节点的实施例
参照图4和图9，假定核心成像将分析节点415和420是否可以组合。在步骤9100处开始，在大多数实施例中，如果节点415的输出在本质上足够接近节点420的输入，则核心成像将试图组合这些节点。在多个实施例中，节点415的输出必须与节点420的输入相同，因为输出缓冲器必须是其中输入纹理驻留的地方。然而，在其它实施例中，核心成像可以估计这样的输出和输入是否足够相似以产生正确结果，或者在另外的实施例中，产生接近正确的结果。
返回到决定9100，如果相应输出和输入不是足够地相似，那么节点不能组合，如在步骤9103中指示的那样。然而，如果相应输出和输入足够地相似，那么控制前进到步骤9101，以检查与第二节点(在这个例子中，节点420)相关的分段程序的每条线。我们以后将讨论线检查，但对于这级的过程，我们假定检查每条线而看到它没有否定组合节点415和420的可能性。另外，在某些线中进行微小变化以利于组合。因此，如果在步骤9101处的线检查导致否定节点组合，那么节点415和420将不组合，如在步骤9103中指示的那样。可替换地，如果在步骤9101处的线检查指示对于节点组合的继续可能性，那么控制前进到决定步骤9102，在该处确定硬件是否能处置组合节点。在一般的意义上，这可能参考在系统中的任何硬件限制，如存储器、任何微处理器的性质或系统状态。在更具体的意义上，大多数实施例只需要检查驻留GPU的能力以看是否有需要太多查找表或寄存器。显然，(除非使用估计)如果步骤9102确定驻留硬件不能处理节点415和420的组合，那么不能进行组合，如在步骤9103中指示的那样。可替换地，如果步骤9102确定硬件能处置组合节点，那么控制转到步骤9104，在该处一系列任务开始以结束节点的组合。
在步骤9104中，用于节点的程序代码实际上被级联。在步骤9105中，应用标准预编译器优化器程序。这不是作为对于本发明的某些实施例的主题的优化。相反，这是容易可得到的预编译优化例行程序。其次，在步骤9106中，应用指令以分配寄存器。最后，在步骤9107中，为了将来的组合分析而高速缓存结果。
在讨论这个例子时，已经仅很少地注意步骤9101，该步骤9101是在第二程序中的每条线的检查。现在参照图10，我们将更详细地探索该过程。在步骤10107处，核心成像寻找用于分析的下个程序线。下条线可以是代表第二节点420的程序的第一条线。控制前进到决定步骤10100，在该处核心成像确定在程序线中是否有局部变量。如果有这样的局部变量，那么控制前进到步骤10101，因为这样的局部变量必须重新命名，从而它们不与在第一程序(在这个例子中代表节点415的那个程序)中的局部变量相冲突。在某些实施例中，所有局部变量被编号有从在每个分段程序中的零开始的顺序整数。因此，在重新命名在第二分段程序(代表节点420的那个)中的局部变量时，(1)通过简单地添加到在第一程序中的最高编号局部变量上而导出第一新名称；和(2)使用第一重新命名局部变量作为基础名称，顺序命名以后的局部变量。
一旦重新命名在程序线中的局部变量，控制就前进到决定步骤10102，在该处核心成像寻找在程序线中的纹理基准。值得注意的是，如果没有要求重新命名的局部变量，则决定步骤10100也引导到步骤10102。在任一种情况下，在决定步骤10102处，核心成像寻找在程序线中的任何纹理基准。如果没有找到纹理基准，那么控制前进到决定步骤10105。如果找到纹理基准，则控制前进到步骤10103，以看找到的纹理基准是否第一节点(415)的处理的产物。如果找到的纹理基准不是第一节点的处理的产物，那么控制前进到步骤10108，以便如有必要则重新命令纹理。
假定找到的纹理是第一节点的处理的产物，那么控制从步骤10103前进到步骤10104，以用单一象素替换纹理。在一般的意义上，我们用单一象素替换纹理，因为尽管分段程序具有用于输入的全部纹理和用于输出的全部缓冲器，但分段程序一次只处理一个象素。因此，如果核心成像将组合或级联两个分段程序，则这些程序必须重写以使同一象素通过被组合程序的整个延伸长度-可能没有由单一(组合的或其它)分段程序创建的中间缓冲器。结果，在某些实施例中，步骤10104涉及消除对于主题输入纹理的任何基准、以及使用在操作下将保持象素的寄存器基准替换它。在步骤10104完成之后，控制转到步骤10108，以便如有必要重新命名纹理。
纹理重新命名的原理和过程与局部变量重新命名相同，所以不需要进一步具体地评述。在纹理重新命名发生之后，控制前进到决定步骤10105。
在决定步骤10105处，核心成像检查对于在由寄存器识别的输入纹理中的象素的任何基准。为了详细说明这个步骤，假定到第二节点(42)的输入纹理是纹理α。也假定纹理α已经从程序写出以有利于在寄存器β中的象素。在步骤10105处，核心成像正在寻找对于除存储在寄存器β中的象素之外的、纹理α的象素的任何基准。这是因为，两个分段程序的组合将消除纹理α的创建(中间图像)，并且，在运行时间，系统对于纹理α的唯一基准将是在寄存器β中的单一象素。因此，如果位于第二节点(420)下方的程序具有对于除存储在寄存器β中的象素之外的象素的实质基准，那么组合不能发生，并且必须如在步骤10106中表示的那样中止。如果没有对于这样一个象素的基准，那么程序控制前进到步骤10107，以运动到下条线。
在回顾这里描述的程序步骤时，应该注意，有借助于描述的功能和变化处理代码的线的多种方式。例如，程序可以在每条线中一次观看一项，并且在运动到在同一线中的下一项之前处理完用于特定项的所有选项，直到单条线结束。对于另一个例子，程序可以读取第一项，并且：检查它是否是局部变量，并且如果是则重新命名它；检查它是否是纹理基准，并且如果是则检查基准是否到第一程序的输出，等等。要点是，给出公开的技术，熟练程序员可决定如何进行分析和线检查。
4.把计算和存储限制到定义域
在一般意义上，图像不由除了它们在其中存在的坐标系之外的任何东西约束。对于大多数坐标系，这个“边界”不施加有用的限制。因此，当考虑图像时，我们可以考虑它的定义域。图像的定义域是其中定义图像的所有地方的表示(因而有名称“定义域”)。考虑定义域的实际方式是关于在图像中清楚定义并且不透明的所有地方的表示。定义域的一个例子是所有非透明象素位于其中的几何形状。
在开发优化技术时，定义域(“DOD”)是令人感兴趣的，因为不必计算或画出在DOD外的象素。因此，在优化图形时，在首先计算根节点(真正最高节点，例如图4的节点415)的DOD时有用。一旦你具有根节点的DOD，你就可以使该形状与节点的实质结果相交，并且从呈现和绘制任务中消除驻留在DOD外的实质结果的所有部分。不幸的是，节点的DOD不总是适用的，并且当情况是这样时，必须认为DOD是无限的。
在一般意义上，通过从图形的底部向上扩展而计算根节点的DOD。参照图4，我们通过从叶节点424、425、426、427、428及429开始计算根节点415的DOD。由于叶节点代表已经定义的图像，所以它们可能具有DOD而不用参考下部节点(实际上，叶节点通常是在图形中的读命令)。更高级节点的DOD使用到节点的输入和该节点实现的功能而计算。在某些实施例的实践中，在系统中的每种节点类型具有功能调用，以鉴于其可能输入确定其DOD(这是看待节点可能包括其输出DOD的早先叙述的一种方式)。在替换实施例中，优化程序在优化期间计算DOD本身。在又一个实施例中，来自某些节点的DOD在优化期间直接计算，并且其它节点通过调用功能而间接计算。例如，一个实施例可以对于容易节点(其中输入和输出形状相同的那些)直接计算DOD，并且对于困难节点(其中输入到输出形状变化的那些)进行功能调用。为了说明，我们将非常简要地回顾DOD的计算。
DOD的这种计算依据被分析的节点的类型稍微变化。例如，如果节点418的功能简单地是颜色转换，那么节点417的DOD将与叶节点424的DOD相同。这个相同例子应用于不改变输入图像DOD的形状的所有操作(即，范围变更、颜色空间转换及图像色调)。然而，某些节点可能计算起来更复杂，因为它们具有多个输入，或者因为所述功能改变输入节点的DOD的形状(例如，几何变化)。首先观看多节点问题，假定我们希望计算用于节点416的DOD，已经具有节点417、418及419的DOD。用于节点416的DOD是多个输入节点的DOD的简单函数，并且通常是多个输入节点的DOD的合集或者交集。结果DOD是否是交集、合集、或者稍有些更复杂的函数，取决于节点的功能，并且容易由任何程序员访问。
在计算DOD时，由功能引起的图像形状的变化需要更多考虑。这些类型的功能没有限制地包括像模糊之类的项目，其中图像由于功能的纯操作而改变形状(像模糊或缩放操作-通常模糊将使图像更大)。替换地，所述功能可以简单地重新定向图像(旋转、偏移等等)，该操作可以改变在坐标系中的位置。在任一种情况下，大多数实施例将需要调用DOD用于输出的功能，该输出基于任何可能的输入。任何熟练程序员可写这样的功能。
最后，回顾某些节点将没有定义的DOD。在这些情况下，大多数实施例将把无限指定为DOD的值。
5.把计算和存储限制到感兴趣的区
有了用于节点的DOD，我们现在可确定用于相关节点的感兴趣区(“ROT”)。总之，感兴趣区是计算给定输出DOD必需的输入图像的部分。因此，尽管每个节点在其输出具有DOD，但它具有用于每个输入的ROI(在观察图形时，你可把这个概念化为用于每个链接的ROI)。作为ROI的例子，假定是模糊的节点功能具有是“大矩形”的输入图像和是“小矩形”的输出DOD。用于这种模糊的ROI功能将返回一种形状，该形状对于计算在输出DOD中的模糊结果的部分，定义输入图像“大矩形”的什么部分是相关的。理解这个ROI区的值是我们只需要存储输入图像的相关部分，所以我们节省了用来存储中间结果的存储器(以及关于最终结果的某些)、以及把效果施加到可能最终是无关的象素上的处理时间。例如，出现在链接46处的缓冲器只需要存储相关结果，该相关结果是节点24的输出DOD与节点17的ROI的交集-这样的交集是优化结果区。
像DOD计算，在某些实施例的实践中，所述功能用来确定节点的ROI。像DOD，某些ROI容易确定，因为他们简单地与在跨过节点的链接上求出的值相同。例如，如果链接45具有“α”的ROI，并且节点417是颜色转换，那么用于链接46的ROI也是α。然而，如果节点417是模糊，那么确定用于链接46的ROI就更困难(它非常可能与α不同，并且或许更小)。在某些实施例中，与节点相关的功能将被调用，以解出难以确定的ROI。在替换实施例中，优化例行程序在优化期间计算ROI本身。在又一个实施例中，用于某些链接的ROI在优化期间直接计算，并且其它链接通过调用功能间接地计算。例如，一个实施例可能对于容易的链接(其中输入和输出形状相同的那些)直接计算ROI，并且对于困难的链接(其中输出形状与输入形状不同的那些)进行功能调用。为了说明，我们将简短地讨论ROI的计算。
像DOD计算，ROI计算必须通过图形树扩展，尽管如以上暗示的那样从根向下(不是像DOD那样从叶向上)。当要求核心成像执行图形任务时，要求实体提供用于输出的ROI，所以我们可假定根节点(例如，415)是已知的。为了确定其它ROI，我们简单地通过图形树往回传播。例如为了计算用于输入/链接43的ROI，我们考虑在415的结果和功能处的“已知”ROI。
6.ROI和DOD示范实施例
如早先讨论的那样，应用程序将使用核心成像API构造高级图形。使用这些图形的一个、或者通过其它装置，应用程序的程序员把图形任务提交给核心成像。参照图11(a)，假定任务是绘制所得到的ROI。参照图11(b)，用于核心成像的第一任务是创建低级图形，步骤11100。尽管在创建低级图形(表示成在图11(a)中的树)时涉及得较多，但为了这个例子的目的，唯一重要的是知道，包括全局DOD(根节点116的DOD)的输出DOD将被计算，并且在这个步骤11100的结束处将表示在节点中。其次，在步骤11101中，核心成像求出全局DOD和所得到的ROI的交集。为了方便起见，我们把这叫做“结果交集”。
核心成像然后继续到判定步骤11102，以确定是否有更多节点要检查。这种确定11102可以以对于熟练程序员清楚的任何适当方式进行。如果没有另外的节点要检查，那么程序在步骤11103中完成这个优化任务，并且准备好适时编译。返回到“更多节点？”判定11102，如果有更多节点要优化，则核心成像将确定用于下个节点的输入的ROI。有各种熟知方式确定在走过树时哪个节点是下一个，所以我们在这里将不讨论该主题。
为了我们图11例子的目的，我们仍然在节点116和步骤11104处，计算用于节点116(根节点)的输出ROI的任务。如早先讨论的那样，这可以直接地或通过调用功能而确定。在任一种情况下，用于链接114和115的ROI被确定，并且插入在图形中。
在对于节点116输入确定ROI之后，核心成像返回到判定1110以回答查询“更多节点？”。在这种情况下有更多节点，核心成像运动到步骤11104以确定节点115的输入ROI。注意，由于节点113是叶节点，并且没有输入，所以没有用于节点113的ROI计算。因此，输入ROI对于链接118和112而确定，并且插入在图形中。
核心成像返回到步骤11102，并且确定有更多节点，所以再次前进到步骤11104，以确定用于节点114的ROI。再次注意，112是叶节点，所以没有必要计算。用于111的ROI被确定，并且输入图形中。
控制返回到决定节点11102，并且确定没有更多节点(节点111是叶)。核心成像前进到步骤11103，完成！
图形对于ROI和DOD现在被优化，但其它优化，如节点合并和高速缓存，可以在这个上分层或者可以同时地进行。
7.递归执行实施例
如早先提到的那样，程序员可以求出以各种顺序组织优化技术的效率。然而，当前发明的某些实施例仅跨过图形的部分以已定义顺序实施技术的一种或多种。具体地说，相同(或相似)程序顺序可以递归地应用于图形的一部分，一次一部分。这种方法通过为存储器重新使用和顺序处理(到某一程度)提供机会而允许效率增加。为了简单起见，从这些实施例的讨论中大都省去高速缓存的概念。然而，给定这里的公开，本领域的技术人员将理解何处应该实施高速缓存步骤。
为了说明，参照图12，其中表示用于本发明的递归执行实施例以达到结果的流程图。换句话说，该例子的目的是计算根节点。在步骤12100处，核心成像试图把根节点与相邻节点组合。如果节点可以组合，则该过程被执行，可能吸收沿每个输入链接到根节点的多个节点。控制前进到步骤12101，在该处核心成像确定用于(可能合并的)根节点的DOD。一旦DOD已知，控制就转到步骤12102，在该处对于到根节点的子链接计算ROI。有了ROI和DOD，两个可以相交集，以确定结果的区。控制现在转到步骤12104，以产生用于根节点的输入的纹理。这些输入纹理是必要的，以便呈现根节点。然而，常常是，节点的输入纹理是未计算的，并且仅由图形表示。在这些情况下，核心成像可能需要在每个从属节点上递归地处理与在这个例子中描述的那些相类似的步骤。因此，在图12中表明的过程可以以嵌套方式应用，以沿图形运动并且解出最终必须解出的节点，以便计算根节点。换句话说，用来解出节点的过程以嵌套方式应用，直到控制解出计算用于到根节点的输入的纹理所必需的所有节点。在根节点输入纹理被计算之后，控制前进到步骤12104以便创建用于结果的缓冲器。最后，控制前进到步骤12105，在该处GPU被用来把结果呈现到在步骤12104中创建的缓冲器。
应该理解，高速缓存的注释故意从以前描述中省去，以便着重于递归过程。然而，高速缓存可以用在各种地方，包括节点结果和节点组合分析与结果，对此没有限制。
而另一个递归处理实施例由在图13中的流程图表示。然后参照图13，步骤131指示我们正在试图计算根节点。在这样做时，步骤132确定是否有可能把根节点与相邻节点组合。根据步骤133，如果组合是可能的，则进行组合，并且组合继续发生(通过步骤131、132及133)，直到确定没有进一步的组合是可能的。在这样的确定之后，控制转到用于DOD和ROI优化的步骤134和135。其次，决定步骤136确定现在是否可能呈现根节点。如果计算到根节点的所有输入，则才可能呈现根节点。因此，假定对于决定136的回答是否，控制转到步骤1310，用于产生欠缺子纹理的任务，该欠缺子纹理对于解出根节点是必需的。这里值得注意的是，在1310下面发生的过程与用来解出根节点的整个过程非常相似。具体地说，相同的例行程序用来解出子节点和根节点。然而，这些例行程序可以以嵌套方式调用，以解出在图形中的多个节点。可替换地，这些例行程序可以并行地运行，以便一次解出几个节点，甚至解出在非相关图形中的节点。
现在返回步骤1311，必须确定下个子节点，这简单适当地选择待分析的下个节点。步骤1312和1313与步骤132和133类似。步骤1314、1315及1316与步骤134、135及136类似。步骤1317(为了简短)与步骤137和138类似。步骤1319指示，当子节点由于其输入纹理的不适用性而不可呈现时，可能在嵌套计算中计算下个节点(步骤1311)。类似地，步骤1318指示在已经解出并呈现节点之后非嵌套水平的可能性。
最后，在步骤1311处，如果没有更多子节点要解出，则控制可以转到步骤137和138，在该处为根节点的结果形成缓冲器，并且把根节点呈现成上下文。
对于递归运算的又一个实施例，参照图4和14，并且假定在图4中表示的图形必须由核心成像优化和呈现。在根节点415处开始，通过计算全局ROI与全局DOD的交集，核心成像可以从步骤14100开始。控制前进到步骤14101，以确定是否有下个节点。如果没有下个节点，那么处理完成，如在步骤14106处指示的那样。然而，在这种情况下，根节点415是下个节点。控制转到步骤14102，以得到用于在输入链接42上的节点415的输入ROI。已经得到这样的输入ROI时，控制转到判定14103，以确定415/ROI的结果是否在高速缓冲存储器中。如果415/ROI图像在高速缓冲存储器中，则控制回到判定块14101，以检查是否有另外的节点要处理(回顾，如果在高速缓冲存储器中找到该结果，则系统不必处理找出节点下面的全部图形)。在这种情况下，假定415/ROI的结果不在高速缓冲存储器中，所以控制转到缓冲器分配步骤14104。在这个步骤处，缓冲器被定义，并且针对415输入ROI的尺寸可以被分配。控制然后转到判定步骤14105，以确定节点(415)在这时是否可以呈现。在实际中，这可以是把节点415呈现到之前刚定义的缓冲器中的命令。
如我们从图4看到那样，节点415是根节点，并且不准备呈现。我们以后将处理关于步骤14105的肯定决定。由于节点415不准备呈现，所以控制转到步骤14107，以确定下个相邻节点是否可以叠并(collapse)到节点415中，在该步骤处，系统必须确定节点415是否可以叠并到下个相邻节点(在早先更详细讨论的那样)。如这里其它处讨论的那样，组合决定和操作可能涉及第二高速缓存系统，借此系统可查阅两个节点是否可以叠并，并且如果是，则结果为叠并。
返回到在步骤14107处的决定，如果415可以与相邻节点组合，那么控制前进到步骤14112，并且实现组合。控制然后回到节点14101，在该处用于分析的下个节点是新创建的415。如果步骤14107确定组合是不可能的，那么控制回到决定步骤14101，以确定用于分析的下个节点。在某些实施例的实践中，在步骤14107处为“否”，留下节点415未解出，并且返回到步骤14101，以嵌套方式在下个节点上运行例行程序。嵌套可以到无限深，并且将最终通过在下个节点步骤14101处解除嵌套(一次一个嵌套)而解出。
现在返回到步骤14101，我们确定下个节点是420，所以控制转到步骤14102，以检索或计算用于节点420的输入ROI。一旦ROI被确定，则控制转到判定节点14103，在该处在高速缓冲存储器中检查420/ROI组合。假定欠缺一个高速缓冲存储器，控制转到步骤14104，并且分配缓冲器。控制然后转到步骤14105，用来决定呈现是否可能(同样，在实践中这可以简单地是呈现420的尝试)。图4告诉我们，节点420不能呈现，所以控制转到步骤14107，关于叠并节点的可能性的判定。假定判定也是否定的，并且控制返回到步骤14101(在某些实施例中，对于例行程序的第二次嵌套)。
在步骤14101处，确定下个节点是节点422。输入ROI在步骤14102处被确定，并且控制前进到在步骤14103处的高速缓冲存储器检查。现在假定我们具有命中的高速缓冲存储器，从而解出存储节点422和在它下面的所有节点。控制然后移回步骤14101，在该处下个节点成为节点421(因为在链接49之后的树的小部分，节点420仍然不能呈现)。对于421，在步骤14102处确定输出ROI，并且我们将假定在判定14103处欠缺高速缓冲存储器。在步骤14104处，我们定义用于421ROI的缓冲器，并且在步骤14105处发现，节点421可以呈现(节点427和428是树叶或输入图像，所以它们不阻止节点421的呈现)。
鉴于呈现节点421的能力，控制转到用于ROI/DOD优化的步骤14108。这里我们使节点421的输出DOD与节点20的输入ROI相交集，以使在呈现期间将被写入的我们的最终缓冲器的尺寸最小。在某些实施例中，将调节在步骤104中进行的缓冲器设置。节点421然后转到编译器(步骤14109)，并且呈现编译结果(步骤14110)。在呈现(或在这个过程的某些点处)之后，多个实施例将重新考虑由缓冲器引起的存储器使用率、和是否该空间可以设置为自由或被重新使用。我们在步骤14111中表示这种考虑。
控制现在返回到步骤14101，在该处最终确定节点420准备呈现(步骤14105)。呈现如以前描述的那样发生，并且控制将最终回到步骤14101，用来考虑节点410。如果假定节点410/ROI被高速缓存，那么对于我们的结果节点415最终将发生呈现。
F.简单代码例子
为了说明，如下是代码的例子，表示核心成像API如何可以用于简单的曝光滤波器：
CIImage*image，*result；
CIFilter*bright；
CIContext*context；
CGImageRef cgImage；
context＝[CIContext contextWithCGLContext：someGLContext]；
image＝[CIImage imageFromCGImage：someCGImage]；
bright＝[CIFilter filter WithName：@″CIExposureFilter″]；
//filter parameters set via key/value coding
[bright set Value：image forKey：@″inputImage″]；
[bright set Value：[NSNumber numberWithFloat：-2.0]forKey：
@″inputExposure″]；
result＝[bright outputImage]；//result is still just a″promise″
[context render：result]；//forces evaluation
也为了说明，如下是根据本发明实施例的组合分段的例子。
program 1：
MOV r0，program.local[0]；                        --r0＝local variable 0
MUL r1，r0，program.local[l]；                    --r1＝r0*local variable 1
MOV result.color，r1；                            --output pixel is r1
program 2：
MOV r0，program.local[0]；
TEX r1，fragment.texcoord[0]，texture[0]，RECT；  --r1＝sample(texture
0，coord 0)
MUL r2，r0，r1；                                  --r2＝r0*r1
MOV result.color，r2；
combined program：
MOV r0，program.local[0]；
MUL r1，r0，program.local[1]；
MOV r256，r1；                                    --save output pixel
MOV r0，program.local[2]；
MOV r1，r256；                                    -replace texture lookup by
previous output
MUL r2，r0，r1；
MOV result.color，r2；
G.核心成像产生CPU和GPU代码
在编译高级滤波器组合时，核心成像可以在呈现期间产生用于执行的多个对象。核心成像的这种特征可以广泛地应用于具有多个相异处理器的系统。例如，有用的可能是，进行适时编译，以划分在操作航空器上进行的天气预报计算。适时编译允许高效率算法在当确定使用哪些处理资源时说明航空器(飞行)的状态。这种一般过程可以概括成七个步骤，尽管有效系统可能在这些步骤的子集上操作：(1)检查哪些资源适于采用，如处理器、控制器及存储器空间；(2)估计资源的每一个的能力；(3)检查每个资源的操作状态；(4)估计当前任务的要求；(5)相对于适用资源的一些或全部，分析任务的要求；(6)优化和编译软件以满足任务的要求，同时增加在系统中硬件使用的整体效率(一般减少由任务使用的资源，但或许在已利用或未使用资源下使用)；及(7)执行编译代码。值得注意的是，依据实施例，步骤一至五可以在执行时间或之前发生，而步骤六和七如果在执行时间或其附近发生，则在过程中是最有用的。
有用于这个过程(整个或截短的)虚拟无限应用程序，这个过程可考虑硬件能力、任务的性质及困难、及在确定工作的高效划分时的实时状态。虽然有这些虚拟无限应用程序，但有核心成像将产生CPU代码的三种普通原因。这些原因之一是用来在CPU上仿真GPU，并且这在以后讨论。第二原因是为了严格的效率，通过使用CPU进行离线呈现。最后原因是为了绝对的必要性，如当任务超过GPU的硬件能力时(这在以后部分中也进行某些讨论)。
假定在别处讨论第一和第三原因，我们通过提供例子在这里简短地讨论第二原因。对于多个处理器的主要好处是并行工作的能力。当应用程序提交要求滤波例行程序的串行施加的任务时，并行最容易地被建立。举例来说，参照较15(a)，该图表表示在6帧序列上串行工作的CPU和GPU的计时。为了这个例子的目的，有两种效果顺序施加到每个帧上，CPU施加第一效果，并且GPU施加第二效果。GPU开始帧一，而GPU是空闲的或在其它事情上工作。在第一效果施加到帧1上之后，帧转到GPU以施加第二效果。在GPU把第二效果施加到帧1上的同时，CPU正在把第一效果施加到帧2。过程继续(表示在图表15(a)中)，从而使用简单的并行，以便非常高效地利用硬件并且迅速把两种效果施加到流上。参照图15(b)和15(c)，表示有传输用四个处理器(图15(b)或两个处理器(图15(c))施加四种效果的类似图表。值得注意的是，在图15(c)中的嵌套能以多种方式排列，并且对于任何数量的处理器施加有任何数量的效果。通过串行化效果的施加而实现效率。如果每种效果所要求的工作最佳地适于执行任务的处理器，则可进一步提高效率。例如，在图15(a)中，如果CPU较好地适于施加第二效果，那么颠倒在CPU与GPU之间帧处理的顺序。
H.仿真：核心成像产生CPU代码
如以前讨论的那样，在过去几年期间，灵活的图形相关硬件和软件技术已经进化，并且为甚至更有用的技术提供基础，如本发明的多个实施例。具体地说，诸如OpenGL和可编程GPU之类的技术的进步已经为这里描述的革新的多种提供了工具。然而，这些工具不必是向后兼容的，因为核心成像的功能性的全部都不可能在每个平台上运行，因为缺乏实现的基础结构(例如，可编程GPU)。因此，如果有依赖于核心成像的服务的程序员和程序，则这些程序员和程序可能在具体平台上受到损害，如果是核心成像服务的一些或全部不可用。
作为实际例子，如果设计操作系统以提供像核心成像的功能之类的功能，那么假设应用程序被设计成形成高级图形调用，像在这里的实施例的多个中描述的那些。然而，当你设想尝试在较旧计算机上运行这些应用程序时，即使假定已经采用新的操作系统，也产生问题。明确地说，如果对于核心成像进行调用，则产生问题，GPU通常为该核心成像提供呈现。为此，有用的是，核心成像包括仿真能力，从而其功能性的全部或最大部分可以在任何平台上适用。
因此，由非常高的级别(系统功能)我们可看到，有时仿真器如果不是必要则也是非常有用的。然而，尽管核心成像的遗传适用性提供对于本公开的激励，但这里的革新不受此限制。因此，我们将具有关于其中可以采用仿真器的更准确环境的简短讨论。具体地说，我们已经提到在没有可编程GPU或根本没有任何GPU时仿真器的有用性。然而，另外，即使包括GPU的系统对于仿真也可能具有有益的用途。具体地说，问题可能超过具体GPU的资源极限。例如，在当代GPU中，超越2048×2048的图像一般太大。另外，结果的精度可能要求CPU(某些GPU，如当前可从ATI得到的那些，仅使用24位浮点)。当然，有多种可能使仿真器有用以解决具体图形或节点的其它硬件限制和可能的低级软件考虑。
1.做出仿真的决定
依据主机系统的性质和用于仿真的原因，在各种时刻可以做出仿真的决定。例如，在缺少可编程GPU支持的系统中，软件开关永久地设置构造以仿真适当的图形调用。可替换地，在对于特定任务已经调用核心成像之后，可以进行判定。在这种情况下，可以考虑任务的性质以及驻留GPU的特定能力、及甚至可能的过程状态与硬件项目。在某些具体实施例中，核心成像在图形调用时做出关于仿真的决定。在这些实施例的某些中，当没有驻留的GPU或者驻留的GPU不是可编程的时，使用仿真。在这些实施例的其它实施例中，在图形优化已经至少部分施加并且确定GPU不能处理特定段、或者这样的特定段更适合通过在CPU上仿真而处理之后，做出所述决定。在又一个实施例中，仿真决定可能取决于图形请求的源或输出的目的地。这是因为对于图形请求的整个系统响应可以通过改进存储器操作的速率而改进。例如，如果要求核心成像把结果呈现到系统存储器，则该最终目的地是倾向于仿真的一个因素，因为仿真发生在CPU上。对于主存储器的访问一般来自CPU比来自GPU快。同样，在视频Ram中的存储器操作一般来自GPU较快。因此，如果要求核心成像呈现到VRAM，则这是倾向于使用GPU的因素。
2.作为在软件堆栈中层的仿真
参照图3(a)和3(b)，我们已经把核心成像描述为一般在区域3100和3101中提供服务。对于核心成像仿真器的多个实施例，我们可能提到在OpenGL 36或320的层中存在的服务。因此这些实施例的仿真器提供一般在OpenGL处的相同级别处的服务。这是与其中仿真器提供在OpenGL下面的服务的其它实施例的差别。因为前面实施例通过仅在OpenGL(或类似就位的服务)功能的子集上提供仿真而部分实现性能，所以出现差别。在替换实施例中，仿真器可以是OpenGL的部分(或类似)实施。在又一个替换实施例，仿真器可以在OpenGL下面(或类似服务)，并且提供更加综合的覆盖。当然，这可能以性能为代价。
在讨论当前发明的仿真器实施例时，我们将提供关于两组实施例的更具体讨论。一组实施例涉及把GPU程序(例如，分段程序)直接编译成用于一个或多个目标CPU的机器代码。第二组实施例涉及字节编码的虚拟机器，其中每条GPU指令由在高级编程语言中的功能(如3)模型化。在任一类型的实施例中，优选的是，尽管不是必要的，从低级图形开始。此外，由于以前所讨论的图形优化可以减少节点、存储器及计算，所以也优选的是，从优化的图形开始。由于仿真器与可以是节点的一部分的分段程序一起工作，所以仿真器任务可以视作在以前描述的图形游动和分辨率技术之下的层。
I.把GPU程序直接编译到机器代码
一旦已经做出决定仿真，多个实施例就使用如下一般过程用于CPU准备程序。给定我们的以前讨论，应该清楚的是，我们假定从GPU节点开始。更具体地说，这通常可能是与在图形中的节点相关的分段程序。每个分段程序具有一条或多条GPU指令。(我们可以把这些叫做线)。在程序中的每条线然后翻译成CPU等效指令。多条线，如包括添加指令的那些，可以具有单指令CPU等效物。其它线要求更密集的仿真，因为分段代码的单条线必须翻译成多条CPU指令。翻译的任一类型(一对一或一对多个)可以以熟练程序员可以识别的任意各种方式实现。在一个优选实施例中，指令翻译通过大量“如果”语句而出现。在另一个实施例中，表格和查阅表用来把GPU指令与等效的一条或多条CPU指令对准。
在翻译步骤期间，GPU代码可以从任意级的GPU指令翻译成任意级的CPU指令。例如，从GPU汇编到CPU汇编可以发生翻译。在一个优选实施例中，翻译发生在GPU汇编与CPU机器代码之间，该CPU机器代码在当前实施中是二进制的。
一旦程序表达为CPU指令，代码就可以展开。代码展开和最终指令调度是利用指令级并行(“ILP”)的相当标准的优化技术。ILP的一般目的是增加由软件指令采用的硬件并行的量。实现这个的一种方式是重新排列指令以使性能最大化。更明确地说，没有相互依赖性的指令组可以并行地执行。循环展开是一类ILP技术，借此通过采用在循环中固有的并行而获得效率。这在图形操作中是重要的，因为单个分段，或者更具体地说，其CPU仿真等效物，将运行许多、许多循环，以便解出多个象素(每象素一个循环)。在循环展开时，循环的n个实例被展开—就是说，循环代码的n个实例被写在程序线中(例如，如果在循环中有10条线并且n是4，那么会有展开代码的40条线)。最后，展开代码必须建立以便以这种形式运行，意味着，可能有对于变量的增量和分支或重新启动循环的转向指令的必要调整。在展开之后，程序调度然后用来优化展开代码，用于在主题硬件上的最大并行。当展开代码最终被运行时，只需要循环原始循环次数的n分之一次，并且每个新循环将以少得多的停止事件运行。
一旦展开，关于代码的下三个步骤就是标准优化、寄存器分配及程序/指令调度。熟练程序员将认识到所有这些步骤可以如何进行，我们将提供非常简短的讨论。我们的描述不打算是穷举的或排他的。可能有我们未提到的多种技术。此外，我们的确提到的所有技术可能不在我们叙述的类别下进行。标准程序优化的目标在于通过诸如代码压缩和重复消除之类的多种技术改进时间和存储器性能。进行寄存器分配，以避免冲突、使使用的寄存器数量最小及扔出没有输出效果的指令。最后，程序/指令调度优化用于具体硬件的流水线和并行的代码。
到此时已经完成非常多的内容，代码在将来被如此高速缓存，这个工作不是必要的。
1.特定示范实施例
参照图16，有用于发明的仿真器的实施例的样本程序流程。程序流程和描述仅打算用于说明。实际实施例可以使用面向对象手段，该手段借助于扁平流程图可能不容易描述。
参照步骤161，程序调用核心成像，以请求通常被约束为多边形的图像的呈现或创建。控制前进到判定162，其中确定是否应该采用仿真器。如果不采用仿真器，则控制前进到步骤164，在该处我们为了本说明的目的而完成。当然，本公开在别处也讨论对于仿真的替换例。
以前已经讨论了对于采用仿真的考虑，我们将假定，步骤162确定使用仿真器并且控制转到步骤163，在该处数据从在核心成像中的其它例行程序被推到仿真器。具体地说，数据是如下：主题分段程序；呈现分段程序需要的纹理；局部变量；及状态。在使这些项目用于仿真器之后，控制前进到判定165，以看对于这个任务是否已经产生CPU机器代码。所述分段程序用作索引进入高速缓冲存储器中。然而，有实现高速缓冲存储器的各种方式。在某一实施例中，高速缓冲存储器查阅表将包括用于所有必要数据的格式。例如，高速缓冲存储器可以切断存储信息的表，该信息如输出的象素格式(32位每象素、RGBA、等等)、和/或每个纹理的象素格式和状态。
返回到判定165，如果有命中的高速缓冲存储器，那么控制跳到步骤169。为了说明的完整性，假定高速缓冲存储器欠缺，并且控制前进到步骤167，以便把GPU分段代码转换成CPU代码。由于用于这种转换的技术在以上被描述，所以我们仅简短地解决问题。在大多数实施例中，这个步骤167进行转换、展开、标准优化、寄存器分配、及程序/指令调度的全部。然而，其它实施例依据早先已经完成的步骤可以完成或多或少的功能。类似的声明也应用于下个步骤168，在该处CPU代码结构被高速缓存。尽管大多数实施例高速缓存二进制机器代码，但熟练程序员可以找到高速缓存较少处理结果的原因。
现在到步骤169，机器代码放置在用于象素估计的N长度循环中。这个循环的工作是估计L个象素。在优选实施例中，L是128。尽管这里描述的本发明适用于用于L的几乎任意值，但本发明人已经发现，在它们的实施中，128的L值在平衡各种考虑(一次进行多个象素的希望、具有由纹理查阅及处理部分块引起的较大开销)方面提供良好性能。因此，如果步骤169的循环是估计L个象素，那么展开代码必须循环与L除以N相等的次数，其中N是在展开代码中表示的循环的迭代数量。那么最终，N等于L/n。因此，如果我们使用我们的128象素每完整循环的优选实施例，并且我们假定4次展开迭代，那么展开代码必须循环32次。
现在到步骤1610，仿真器引起平板(slab)的创建。在优选实施例中，这可以通过功能调用实现。术语“平板”在图形技术中对于其较普通意义被使用。然而，在本实施例中，平板通过在输出多边形上的所有顶点处绘制水平线而形成。例如，见图17，其中在图17(a)中表示有倾斜矩形和划分成平板的同一倾斜矩形。图17(b)表示具有相同关系的梯形；一个表示有画出的平板。
在创建平板之后，控制前进到用于呈现的步骤1611。在优选实施例中，平板一次呈现一块。具体地说，每块平板通过对于在平板中的一个扫描线上找出的L个顺序象素上运行在步骤169中创建的象素循环而呈现。甚至更具体地说，多边形由如下呈现：(i)选择第一平板(假定X、Y、Z球坐标系，在优选实施例中，段可以从最小前进到最大Y值)；(ii)选择在这样的第一平板上的第一扫描线(假定X、Y、Z球坐标系，在优选实施例中，段可以从最小前进到最大Y值)；(iii)使用在步骤169中创建的循环以呈现所述扫描线的最初L个象素，并且然后重复这个步骤，直到扫描线被全部呈现；(iv)运动到后续扫描线(包括对L个象素的部分)，直到在平板中的所有扫描线完成；(v)以类似方式完成所有后续平板。另外，由于核心成像的L个象素的选择对于服务请求者(例如，应用程序)是任意的，某些实施例把呈现结果写出到一个或多个缓冲器，一次一个象素。最终结果然后可按希望的片段放置在请求的目的地中。例如，在L个象素的完成之后，或者在整个部分(如平板)的完成之后，或者在整个多边形完成之后，结果可移动到请求目的地。这个额外步骤也创建用于诸如格式转换之类的任何后处理的方便位置(在缓冲器与被请求目的地之间)。
在讨论跨过扫描线的呈现时，关于其中象素计数不是L的倍数的扫描线的处理，可能出现问题。尽管熟练程序员可以设计用来实施这种情形的各种方法，但本发明的某些实施例在图16中表示的过程的框架内说明这个问题。在一个具体例子中，步骤169的象素循环根据变量，比如说α，循环多次。因此，如果有128个象素并且循环被展开4次，那么α将是32。然而，如果仅有48个象素(例如，在跨过扫描线处理几个128位组之后)，那么α可以设置到12。可选择地，如果有66个象素，则为了处理最初64个象素α可以设置到16，然后α可以设置到一以处理第65和第66象素。总之，这些实施例需要使用变量控制循环和调节该变量以处理变化数量的象素。
用来处置非L个象素倍数的另一种方法是，为变化数量的象素提供展开代码段。例如，如果主循环具有4个展开段，则也可能有用三个展开段、两个展开段及一个展开段创建的代码。因此，如果有3个象素，则可使用三象素代码。如果有一个象素，那么可以使用一象素代码。
也有把以上技术组合的实施例。例如，如果有66个象素，则为了处理最初64个象素α可以设置到16，然后两象素代码可以运行以处置第65和第66象素。可选择地，如果有67个象素，则为了处理最初64个象素α可以设置到16，然后一象素代码可以运行3次以处置第65、第66、及第67象素。
2.平板
多个实施例使用平板。作为对于平板的替换例，能以与描述的相同的方式呈现整个多边形。然而，平板在纹理计算中提供显著的优点。具体地说，纹理坐标对于输出多边形的顶点是已知的。在大多数实施例中，这是因为以上的层(例如，图形优化器)提供这种信息。然而，典型地，硬件可把其基础单元多边形(典型地三角形)的顶点映像到相关纹理映像图上；并且硬件的基础单元多边形的顶点必须与输出多边形的顶点重合。参照图17(a)和17(b)，这些顶点表示为圆点。再次参照图17(a)和17(b)，当形成平板时，它们通常包括不是在原始多边形的顶点上的一个或多个顶点。在图17的所有中，这些“新”顶点表示为三角形。因此，在一个或多个实施例中，当形成平板时，新顶点(在图17中的三角形)的纹理值可以由各种技术计算。某些实施例计算通过由已知多边形顶点内插坐标值而计算用于新顶点的纹理坐标。在优选实施例中，线性内插用来沿分裂平板的边缘内插。每个平板然后将具有三个或四个顶点，该顶点具有已知的纹理坐标。借助于在平板的顶点处的三个或四个已知坐标，通过数学技术，如内插，或更具体地说，线性内插，可以确定在平板上的任何象素的纹理值。
最终，由于平板小于多边形，所以它们提供显著更容易的纹理值计算。具体地说，如对于这点描述的那样，平板包括得到的多边形的一部分，并且作为三角形或四边多边形出现。在三角形的情况下，一旦用于所有顶点的纹理坐标是已知的，任何点的坐标(和最终值)可以用数学(例如，内插或线性内插)计算。此外，当平板是多边形时，程序可以使用多种数学方案，以设计在多边形中一点的纹理坐标。例如，在某些实施例中，程序将挑选三个顶点，并且进行线性内插。
平板的优点可以通过不同形状实现。例如，在某些实施例中，得到的多边形可以划分成所有三角形用来呈现。这可简化纹理查阅，因为总是只有三个顶点。因此，永远不需要做出关于四边多边形的哪三个顶点应该用于内插的决定。另外，熟练程序员可以把在这里讲授的概念应用于其它方案，借此划分的道德多边形以为了呈现。
3.纹理检阅
我们已经讨论了纹理查阅，例如，在平板和多边形顶点的上下文中。我们现在进一步讨论关于如何把纹理查阅高效地包括在已经公开的实施例的某些中的细节。我们必须首先通过描述两种相关类型的纹理查阅并且然后提供可能仿真以前讨论的上下文，而提供用于这种细节讨论的背景。
在仿真任务中，有可能遇到的两种一般类型的纹理查阅。有是进入已知纹理中的坐标的独立纹理查阅。例如，独立纹理查阅可以是在参考在已知纹理中给定坐标的代码中的位置。替换地，有的是取决某些其它项目或事件的纹理查阅的依赖纹理查阅，所以坐标通常编程地放置在寄存器中。例如，这可以是在代码中的位置，其中在寄存器中找到进入给定纹理的坐标。纹理查阅取决于将进驻于寄存器的某些其它操作的结果。
在设置用于纹理查阅技术的上下文中，我们更密切地观看在对于变化实施例描述的仿真器的主循环内的活动。更具体地说，这一般仿真我们参照图16关于169讨论的循环。通过对于图16的这种仿真和参考，在步骤169中建立循环时，比简单地把展开代码放置在循环中以实现128个象素的处理有更多要完成。具体地说，对于每组象素(平板、扫描线或优选的L个或剩余组象素)，必须建立代码。如早先讨论的那样，建立代码的部分可以是，当扫描线包括不是128(L)倍数的象素长度时，代码可考虑剩余象素。另外，对于纹理查阅可以建立所述代码。
现在更直接地着重于纹理查阅的主题，仿真器的优选实施例将建立用于纹理查阅的主循环。在一个实施例中，这样的建立对于每L个象素进行，并且分离地涉及对于独立和依赖纹理基准的建立。对于这些实施例，在建立期间，每个独立纹理基准被查阅，优选地在相同步骤中。并且，对于每个依赖纹理基准，功能插入在代码中以在依赖性已经满足之后进行查阅。为了清楚，对于每次查阅，功能调用插入在代码中。对于在程序中由依赖纹理基准访问的每个纹理单元，创建功能。传递到纹理查阅功能的唯一值是待查阅的坐标和待使用的纹理。更准确地说，代码的这种插入片段将在外部调用所述循环，这样的功能基本上仿真GPU纹理查阅能力。在一个优选实施例中，功能调用从循环内传递纹理、状态及坐标；并且所述功能返回一个向量。然而，这种功能调用可以另外实施。
4.建立
尽管我们已经讨论了建立代码多次，但我们将提供某些说明性实施例。例如，在给定实施例中，可能有对于每个多边形将建立的代码的部分、和对于每块平板将建立的部分、和对于每条扫描线将建立的部分、和对于每个象素组(例如，L个或剩余组)将建立的部分。在给定组中的各种活动可以从这里的其它讨论外延。
J.多个CPU
遵循与先前例子相类似的技术的实施例极良好地适用于多个CPU。这是因为在步骤169(图16)处创建的循环机器代码可以在不同平板或不同多边形上的分离例子中运行。具体地说，核心成像或另一种适当程序通过在处理器之间划分任务，可大大地加速在多处理器系统上的图形呈现。在优选实施例中，发送到每个处理器的任务的增量是平板(或其它子划分)。然而，增量可较小(例如，扫描线)或较大(例如，整个多边形)。
K.字节编码的虚拟机器
虚拟机器也可以用来在CPU上仿真GPU。虚拟机器是行为像硬件的过程，因为它可接收指令并且把处理器资源仿真到另一个处理器。在一般的意义上，虚拟机器仿真器方案的优点在于，虚拟机器更加便携。具体地说，虚拟机器可以以高级语言写入，并且然后对于任何平台被编译。可替换地，把GPU程序编译到机器代码的实施例对于每个硬件平台可以定制地写入。
在一个优选实施例中，本发明需要字节-代码虚拟机器仿真器。形容词“字节-代码”添加如下意思：虚拟机器过程接收编译代码，或在某些实施例的情况下，接收低级代码(与硬件接收的相似)。在高级别下，虚拟机器可能与在讨论GPU到机器代码仿真器的实施例中的CPU相似。更具体地说，虚拟机器可以概念化成位于以前描述的较高级功能和技术之下。因此，先前描述的所有仿真和其它方法和技术可被模拟并应用于所公开的虚拟机器仿真器。然而，有值得独立考虑的虚拟机器的感兴趣方面。
在一个实施例中，虚拟机器包括用来建造输出象素的非常大量的虚拟寄存器。具体地说，现在从硬件的约束释放时，虚拟机器可使用满足其它标准需要(如效率)的寄存器定尺寸。因此，在某些实施例中，虚拟机器将建立用于象素的寄存器，该寄存器是L个象素大(再参照沿扫描线处理的128个象素的我们的例子)。寄存器这样大为主循环处理提供多个选项。在一种极端情况下，寄存器可以起输出缓冲器的作用，使得一次处理一个象素(单象素循环)。在其它极端情况下，在主循环中的每个步骤可以在运动到下个步骤之前对于每个象素实现(这与完全展开循环相相似)。作为在这些极端情况之间的平衡，某些实施例将实施所述虚拟机器，以概念地尽可能多地展开循环，而不招致依赖性问题。依据系统考虑，象素寄存器可以是L的倍数或L的分数。此外，象素寄存器也可以动态地实施，以与扫描线的大小或多边形工作段(如平板)相匹配。
在实际中，当仿真器的实施例正在运行时，它接收来自较高层的指令，该较高层优选地是核心成像的较高层。在概念上，指令可以在任何级别处，但对于优选实施例，指令将是诸如字节代码之类的低级别。虚拟机器然后必须把指令转换成用于CPU的任务。这种转换的第一部分是实现到CPU可识别指令的直接转换的“如果”语句或跳转表。在一个优选实施例中，虚拟机器把GPU指令建模为C功能。在这种类型的实施例中，待仿真的每条GPU指令可能与C功能相对应。C功能然后可以借助于普通编译器转换成CPU可识别代码。最普通地，在优选实施例中，每条仿真GPU指令以诸如C之类的高级语言建模。高级模型被编译，并且结果并入到跳转表的“如果”语句中，以在虚拟机器仿真器的操作期间使用。最后，当在仿真期间的操作元素(如象素)时，CPU向量寄存器可以优选地用来存储向量。
L.仿真功能性的子集
为了产生性能，多个实施例不仿真所有可能的低级图形调用。一般地，通过仅仿真可能的图形指令的子集，实施方式可形成关于支持调用的更多假设，并因此避免某些偶然性，由此节省工作。例如，在某些实施例中，核心成像没有对于前景正确内插的需要。具体地说，OpenGL对于每个象素、每个内插纹理坐标，典型地要求至少一条划分指令。划分在概念上非常昂贵，并且由于核心成像的这些实施例不具有前景，所以划分是不必要的。通过仅支持操作子集获得的性能的另一个例子是，核心成像的某些实施例仅支持少量纹理格式和目的地格式。这限制数据转换，并且允许较容易的在线代码产生。
作为仅支持功能子集的例子，在一个实施例中，仿真器仅按如下支持OpenGL的功能性的子集：(i)画出四边多边形；(ii)约束纹理；(iii)约束程序；(iv)设置局部变量；及(v)设置目的地。
有实际上应用这种类型的缩减支持的几种方式。最先，定义的高级API可以仅支持这些功能，从而不可能接收不可仿真的命令。例如，如果核心成像仅支持功能子集，那么核心成像仿真器不必支持更多。在该情况下，如果程序或程序员希望使用非支持图形调用，则他们必须通过另一种机构这样做，如对于OpenGL的直接调用或GPU的直接使用。可替换地，一种仿真技术可以用于列出的功能子集(或某些其它子集)，并且另一种技术可以用于所有其它图形调用。例如，五种仿真功能可以通过使用GPU到机器技术的实施例而仿真，而其它功能可以通过虚拟机器实施例仿真。这种布置允许在最普通图形调用上的最高性能和用来支持其它调用的较容易轻便性和编程。当然，这种划分可按其它标准，如服务调用的困难性、或通过各自技术的调用服务的适用性，而画出。另外，两组技术(虚拟机器和CPU到机器)可类似地共同承担用来实施在系统中的整个图形的一个或多个子集的责任。
下面公开核心成像的另一种服务，该服务允许GPU处理图形信息，并且增强图像处理。除对于图像完成滤波器之外，分段程序可用在GPU上，以进行图形操作(或更明确地说，累积图形操作)。累积图形操作的例子包括但不限于画笔划、聚光、弯曲、渲染、颗粒呈现、或光线轨迹。这种累积图形操作可在CPU上实施。
参照图18，在CPU上使用程序以处理累积图形操作的第一技术被示意地表明。公开的技术创建一个累积缓冲器200，它是原始画布或图像的纹理。一般地，累积缓冲器200与画布相对应。例如，累积缓冲器200能够是原始图像的一层、整个原始图像、来自原始图像的象素的集合、或原始图像的向量场，如位移缓冲器。累积缓冲器200包括用于原始图像的象素的多种数据结构中的数据。用于象素的数据结构(R、G、B、A、或X、Y、Z、W)能够是四个16位值的向量。累积缓冲器200用来累积对于原始图像的变化。例如，对于原始图像施加的笔画通过把每次笔画并入在缓冲器200的数据结构群中可以累积在累积缓冲器200中，同时说明以前笔画(或“涂划”)的效果。累积缓冲器200然后可并入原始图像中。
当绘画时，用户可进行多种累积图形操作，如进行颜色画笔划、施加聚光、或弯曲图像的一部分。为了使用累积缓冲器200，“项目”通过利用“选项”并入累积缓冲器200中。如这里使用的那样，项目是指施加到累积缓冲器200上的某些东西。示例的项目包括但不限于，画笔划、涂画、光、弯曲、或局部模糊。如这里使用的那样，操作是指项目如何并入累积缓冲器200中的过程。操作的例子包括但不限于光场的添加、向量位移场的添加、或画笔颜色的重叠。在用户绘画的同时，对于多个项目进行多种操作，以把项目并入到累积缓冲器200中。
为了说明的目的，涂画202示意地表示在图18中。涂画202与通过用户的画笔划的个别颜色场施加相对应。画笔划可包括多个这样的颜色场施加或涂画的重叠。根据公开的技术，CPU使用程序210把关于在数据结构中的数据的项目和操作的结果并入累积缓冲器200中。在CPU上的程序210从累积缓冲器200读取在数据结构中的象素数据，并且读取项目。然后，在CPU上的程序210通过把操作与项目相组合并影响在数据结构中的数据而修改在数据结构中的象素数据。然后，在CPU上的程序210把在结构中的修改象素数据写回到累积缓冲器200，它然后可并入到原始图像中。
尽管有用来处理累积图形操作的适当技术，但以上公开的、使用在CPU上的程序的技术可以使用比所希望的更多资源和存储器。在优选实施例中，与这里公开的那些类似的分段程序与GPU一起使用，以处理累积图形操作。如以前提到的那样，使用分段程序，GPU可同时对于多个条目进行相同操作。
参照图19，示意地表明使用在GPU上的分段程序以处理累积图形操作的技术。如以上提到的那样，绘画涉及借助于多个项目进行的多种操作，以把项目并入到累积缓冲器200中。CPU能够在同一缓冲器上进行排他的读取/修改/写入(RMW)序列。专有RMW序列可防止其它过程同时从缓冲器读取、修改、及写入在相同象素数据结构中的数据。然而，GPU当前不能进行这样的排他RMW序列。即，GPU缺少存储器或寄存器锁定，并且缺少原子指令的能力，所述原子指令使得能够实现在一条指令中的GPU读取/修改/写入，同时也限制对于存储器位置的访问，直到GPU完成指令。因而，GPU不能在保证数据的完整性的情况下读取/修改/写入在数据结构中的数据。因而，下面公开的、使用在GPU上的分段程序的技术也使用栅栏限制，该栅栏限制是在现有技术中已知的，在其它过程对于缓冲器正在进行读取/修改/写入操作时，用来防止对于在同一缓冲器中的数据的访问的技术。
如在图19中示意表示的那样，使用在GPU上的分段程序而处理累积图形操作的所述公开技术创建一个累积缓冲器200。典型过程创建用于原始画布或图像的32位缓冲器。32位缓冲器包括具有四个8位分量的数据结构。相反，借助于所述公开技术创建的累积缓冲器200优选地具有大于8位每分量的数据结构。例如，在累积缓冲器200中的数据结构可具有16位整数、16位浮点、及用于数据的32位浮点分量。具有大于8位每分量的累积缓冲器200打算用于适合GPU计算的复杂数据结构。复杂数据结构包括但不限于高密度定义颜色(光)、向量偏移、及图元球场值。因为累积缓冲器200打算用于适合GPU计算的复杂数据结构，所以应用于累积缓冲器200的项目可以是例如个别扭曲或弯曲、个别聚光、或两维图元球。因此，累积缓冲器200可以是颜色缓冲器、向量缓冲器、或标量缓冲器的任一种，并且能是2、3、或4维的。累积缓冲器200可典型地存储在VRAM中，但可存储在多个位置。这里公开的、优化分段程序图形的图形优化器，可确定用来存储累积缓冲器200的最适当位置。
如以前那样，涂画202为了说明目的示意表示在图19中。涂画202可与笔划的个别颜色场施加相对应。笔划可包括多个这样的颜色场施加或涂画的重叠。对于图像施加累积图形操作与对于图像施加以上讨论的效果或滤波器不同。例如，绘画允许用户把多个画笔划重叠到原始画布或图像上。在计算机上，原始画布表示为位图，并且笔划由施加到位图上的颜色场代表。在绘画的同时，用户可以把多个笔划重叠到位图上。尽管绘画与简单的施加效果不同，然而，每种场颜色与单一施加一个效果类似。因而，多个笔划可表示为多种效果的强烈重叠。
在用CPU处理效果时，内部计算效果的比特-深度分辨率典型地大于效果的生成内部表示的比特-深度分辨率。因此，每种效果的每种施加引起比特-深度分辨率的损失。在CPU上实施累积图形操作的同时，与累积图形操作(如绘画)相关的比特-深度分辨率的损失典型地由如下诸项减轻：(i)当把笔划重叠在画布上时，使用抖动；和(ii)使用颜色的非线性施加，如密度或着色基方法。这些方法采用颜色级别的不同间隔。
用来处理在GPU上的累积图形操作的所述公开技术使用这里公开的分段编程技术，以基本防止与在CPU上实施这样的累积图形操作相关的比特-深度分辨率的损失。此外，用来在GPU上处理累积图形操作的公开技术可通过影响项目和直接把计算项目写入到累积缓冲器200中而节省存储器空间。因为GPU不能进行排他读取/修改/写入序列，所以公开的技术创建分离的效果区域缓冲器222。所述效果区域缓冲器222可典型地存储在VRAM中，但可存储在多个位置中。这里公开的、优化分段程序图形的图形优化器可确定用来存储所述效果区域缓冲器222的最适当位置。
为了创建所述效果区域缓冲器222，公开的技术由累积缓冲器200确定一个效果区域202。效果区域202是累积缓冲器200的相关部分，对于该部分施加到诸如笔划或涂画之类的项目。使用效果区域，因为使GPU处理效果区域202而不是整个累积缓冲器200更加高效。对于画笔划，效果区域202是在画笔划下具有画布部分的区域。对于聚光操作，例如，效果区域202是具有由聚光照亮的画布部分的区域。数据结构体现了关于由例如笔划或聚光影响的画面的这样部分已知的东西。
公开的技术把效果区域202拷贝到一个分离的效果区域缓冲器222中。在GPU上的分段程序230把所述效果区域缓冲器222用作它们用来读取信息的源，并且把累积缓冲器200用作它们用来写入信息的目的地。因而，在GPU上与这里公开的那些相类似的分段程序210从效果区域缓冲器222读取在数据结构中格式化的数据，并且分段程序210读取所述项目或产生直接使用分段程序的项目。在GPU上的分段程序210然后通过把项目与操作相组合并操作在数据结构中的数据，修改在数据结构中的数据。然后，在GPU上的分段程序210把在数据结构中的结果或修改数据写到累积缓冲器200。最后，所述公开技术的分段程序210累积关于效果区域202的顺序效果，并且然后把累积缓冲器200施加到原始画布或图像上。
参照图20，表明借助于所述公开技术使用在GPU上的分段程序来处理笔划的典型步骤250。尽管累积图形操作是在下面讨论的例子中的笔划，但将认识到，典型步骤可应用于其它累积图形操作。所公开的技术优选地借助于具有多于8位每分量的数据结构初始化累积缓冲器，尽管仍然可以使用具有较低位分辨率的数据结构(步骤252)。其次，所公开的技术由用户通过重叠个别颜色场施加或涂画而计算所述笔划(步骤254)。对于每个涂画，所公开的技术进行多个步骤(步骤260-270)。所公开的技术把效果区域读到分离的缓冲器中。效果区域仅是在例如涂画下的累积缓冲器的量。
涂画结果然后由分段程序计算(步骤264)。通过使用分段程序、并且不把涂画约束到8位分量，基本可避免比特-深度分辨率的损失。由于累积缓冲器具有多于8位每个分量，所以我们把累积的所有另外项目以大于8位每分量定义提供到缓冲器中，以保持精度。所公开的技术然后使用与这里公开的那些类似的分段程序，以计算所述项目的结果，如颜色的场或涂画掩模(步骤266)。如这里公开的那样，在GPU上的分段程序基本上可比标准技术更精确。使用另一种分段程序组合涂画和分离的效果区域缓冲器的结果(步骤268)。最后，涂画和效果区域缓冲器的组合的结果被写入累积缓冲器中，从而只有在涂画下的区域受影响(步骤270)。组合和写入借助于分段程序同时地完成。组合的例子包括但不限于颜色内插、Porter-Duff SourceOver合成、及颜色密度添加和内插。最后，用户可进行多个笔划(步骤256)。以上公开的类似步骤可应用于其它累积图形操作。
尽管公开的用来使用GPU的技术已经被描述以便在GPU上处理图形操作(或更明确地说，累积图形操作)，但所公开的技术也适用于使用GPU完成对于除图像数据之外的在数据结构中的数据的其它处理操作。因为所公开的技术克服了GPU不能保持数据完整性和进行排他RMW序列的限制，所以所述公开技术允许GPU除了处理图像信息之外还处理其它信息。
M.样本滤波器列表
在说明书中的各点处，我们已经提到说明性滤波器列表。如下多页专用于该列表。这个列表和伴随参数供说明和讨论的完整性之用。关于上述发明的发明人的实施例，所列出滤波器的每一种可以使用或不使用或者被修改。此外，更多滤波器可以创建，并且这些可以与公开的显著不同。
-------------Filter # 1：CIColorMonochrome--------------

{

       category＝″Color Correction″；
       inputColor＝{class＝CIColor；default＝＜0.6，0.45，0.3，1＞；type

　　＝opaqueColor；}；

　　   inputImage＝{class＝CIImage；}；

　　   inputIntensity＝{

　　     class＝NSNumber；

　　     default＝1；

　　     identity＝0；
				
				<dp n="d51"/>
　　     minimum＝0；

　　     sliderMaximum＝1；

　　     sliderMinimum＝0；

　　     type＝scalar；

　　   }；

　　   name＝″Color Monochrome″；

　　  outputImage＝{class＝CIImge；}；

　　}

-------------Filter # 2：CIEqualize-------------

　　{

　　   category＝″Color Correction″；

　　   inputBlack＝{

　　     class＝NSNumber；

　　     default＝0.25；

　　 　   identity＝0；

　　    sliderMaximum＝1；

　　     sliderMinimum＝0；

　　     type＝scalar；

　　   }；

　　   inputImage＝{class＝CIImage；}；

　　   inputWhite＝{

　　     class＝NSNumber；

　　     default＝0.75；

　　     identity＝1；

　　     sliderMaximum＝1；

　　     sliderMinimum＝0；

　　     type＝scalar；

　　   }；

　　   name＝″Color Equalize″；

　　   outputImage＝{class＝CIImage；}；

　　}
-------------Filter # 3：CISaturate-------------

　　{

　　   category＝″Color Correction″；

　　   inputImage＝{class＝CIImage；}；

　　 　inputSaturation＝{

　　     class＝NSNumber；

　　     default＝1；

　　     identity＝0；

　　     minimum＝-1；

　　     sliderMaximum＝3；

　　     sliderMinimum＝-1；

　　     type＝scalar；

　　   }；
				
				<dp n="d52"/>
　　name＝Saturate；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 4：CIFalseColor--------------
{

　　category＝″Color Correction″；

　　inputColor1＝{class＝CIColor；default＝＜0.3，0，0，1＞；type＝
color；}；
　　inputColor2＝{class＝CIColor；default＝＜1，0.9，0.8，1＞；type＝
color；}；

　　inputImage＝{class＝CIImage；}；

　　inputIntensity＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　name＝″False Color″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 5：CIColorTint-------------
{

　　category＝″Color Correctioin″；

　　inputAngle＝{

　　  class＝NSNumber；

　　　default＝1.047197551196598；

　　  identity＝0；

　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputImage＝{class＝CIImage；}；

　　name＝″Color Tint″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 6：CIColorNegative-------------
{

    category＝″Color Correction″；
				
				<dp n="d53"/>
    inputImage＝{class＝CIImage；}；

    name＝″Color Negative″；

    outputImage＝{class＝CIImage；}；
}
-------------Filter # 7：CIGamma-------------
{

    category＝″Color Correction″；

　　inputImage＝{class＝CIImage；}；

　　inputPower＝{

　　  class＝NSNumber；

　　  default＝0.75；

　　  identity＝1；

　　  sliderMaximum＝3；
　　  sliderMinimum＝0.1；

　　  type＝scalar；
　　}；
　　name＝Gamma；

　　outputImage＝{class＝CIImage；}；
}
------------Filter # 8：CIBrighten-------------
{

　　category＝Color Correction″；

　　inputAmount＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝-1；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　name＝Brighten；

　　outputImage＝{class＝CIImage；}；
}
--------------Filter # 9：CIColorPosterize-------------
{

　　category＝″Color Correction″

　　inputBlueLevels＝{

　　  class＝NSNumber；

　　  default＝6；

　　  identity＝6；

　　  sliderMaximum＝30；

　　  sliderMinimum＝0；
				
				<dp n="d54"/>
　　  type＝scalar；

　　}；

　　inputGreenLevels＝{
　　  class＝NSNumber；

　　  default＝6；

　　  identity＝6；

　　  sliderMaximum＝30；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputRedLevels＝{

　　  class＝NSNumber；

　　  default＝6；

　　  identity＝6；

　　  sliderMaximum＝30；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　name＝″Color Posterize″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 10：CIContrastBrightness--------------{

　　category＝″Color Correction″；

　　inputBrightness＝{

　　  class＝NSNumber；

　　  default＝-0.3；

　　  identty＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝-1；

　　  type＝scalar；

　　}；

　　inputContrast＝{

　　  class＝NSNumber；

　　  default＝-0.3；

　　  identity＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝-1；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　name＝″Contrast/Brightness″；

　　outputImage＝{class＝CIImage；}；
}
				
				<dp n="d55"/>
--------------Filter # 11：CISepiaTone-------------
{

　　category＝″Color Correction″；
　　inputImage＝{class＝CIImage；}；

　　inputIntensity＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　name＝″Sepia Tone″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 12：CIColorControls-------------
{

　　category＝″Color Correction″；

　　inputBrightness＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝-1；

　　  sliderMaximum＝1；

　　  slidcrMinimum＝-1；

　　  type＝scalar；

　　}；

　　inputContrast＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝1；

　　  minimum＝0.25；

　　  sliderMaximum＝4；

　　  sliderMinimum＝0.25；

　　  type＝scalar；

　　}；

　　inputHue＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；
				
				<dp n="d56"/>
　　inputImage＝{class＝CIImage；}；

　　inputSaturation＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝3；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　name＝″Color Controls″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 13：CIGrayscale-------------
{

　　category＝″Color Correction″；

　　inputColor＝{class＝CIColor；default＝＜0.6，0.45，0.3，1＞；type
＝opaqueColor；}；

　　inputImage＝{class＝CIImage；}；

　　inputIntensity＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝2；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　name＝Grayscale；

　　outputlmage＝{class＝CIImage；}；
}
-------------Filter # 14：CIMultiply-------------
{

　　category＝″Color Correction″；

　　inputColor＝{

　　  class＝CIColor；

　　  default＝＜0.75，0.75，0.75，0.75＞；

　　  identity＝＜1，1，1，1＞；
　　  type＝color；

　　}；

　　inputImage＝{class＝CIImage；}；

　　name＝Multiply；

　　outputImage＝{class＝CIImage；}；
}
				
				<dp n="d57"/>
-------------Filter # 15：CIDissolveTransition-------------{
　　category＝Transition；

　　inputImage＝{class＝CIImage；}；

　　inputTargetImage＝{class＝CIImage；}；

　　inputTime＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝1；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝time；

　　}；

　　name＝Dissolve；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 16：CIDisintegrateTransition-------------{

　　category＝Transition；

　　inputEdgeRamp＝{

　　  class＝NSNumber；

　　  default＝35；

　　  minimum＝0；

　　  sliderMaximum＝40；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputMaskImage＝{class＝CIImage；}；

　　inputShadowRamp＝{

　　  class＝NSNumber；

　　  default＝7；

　　  minimum＝0；

　　  sliderMaximum＝15；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputTargetImage＝{class＝CIImage；}；

　　inputTime＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝1；

　　  minimum＝0；
				
				<dp n="d58"/>
　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝time；

　　}；

　　name＝″Slide Disintegrate″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 17：CIRippleTransition-------------
{

　　category＝Transition；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputDisplacement＝{

　　  class＝NSNumber；

　　  default＝50；

　　  identity＝0；

　　  minimum＝-50；

　　  sliderMaximum＝50；

　　  sliderMinimum＝-50；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputSbadingMap＝{class＝CIImage；}；

　　inputTargetImage＝{class＝CIImage；}；

　　inputTime＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝1；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝time；

　　}；

　　inputWaveWidth＝{

　　  class＝NSNumber；

　　  default＝30；

　　  identity＝60；

　　  minimum＝1；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝6；

　　  type＝distance；

　　}；

　　name＝″Ripple Transition″；

　　outputImage＝{class＝CIImage；}；
				
				<dp n="d59"/>
}
-------------Filter # 18：CIFlashTransition-------------
{

　　category＝Transition；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputColor＝{class＝CIColor；default＝＜1，0.8，0.6，1＞；type＝
opaqueColor；}；

　　inputFadeThreshold＝{

　　  class＝NSNumber；

　　  default＝0.85；

　　  identity＝0.85；
　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；
　　inputImage＝{class＝CIImage；}；

　　inputLookupRadius＝{

　　  class＝NSNumber；

　　  default＝45；

　　  identity＝45；
　　  minimum＝0；

　　  sliderMaximum＝330；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputMaxStriationRadius＝{

　　  class＝NSNumber；

　　  default＝2.58；

　　  identity＝2.58；

　　  minimum＝0；

　　  sliderMaximum＝10；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputStriationContrast＝{

　　  class＝NSNumber；

　　  default＝1.375；

　　  identity＝1.375；

　　  minimum＝0；

　　  sliderMaximum＝5；

　　  slidcrMinimum＝0；

　　  type＝scalar；

　　}；
				
				<dp n="d60"/>
　　inputStriationStrength＝{

　　  class＝NSNumber；

　　  default＝0.5；

　　  identity＝0.5；

　　  minimum＝0；

　　  sliderMaximum＝3；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputTargetImage＝{class＝CIImage；}；

　　inputTexture＝{class＝CIImage；}；

　　inputTime＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝1；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝time；

　　}；

　　name＝Flasb；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 19：CISwipeTrainsition-------------
{

　　category＝Transition；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputColor＝{class＝CIColor；default＝＜1，1，1，1＞；type＝opaqueColor；}；

　　inputImage＝{class＝CIImage；}；

　　inputOpacity＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝0；
				
				<dp n="d61"/>
　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputTargetImage＝{class＝CIImage；}；

　　inputTime＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝1；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝time；

　　}；

　　inputWidth＝{

　　  class＝NSNumber；

　　  default＝600；

　  　identity＝600；

　　  minimum＝0.1；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0.1；

　　  type＝distance；

　　}；

　　name＝Swipe；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 20：CIModTransition-------------
{

　　category＝Transition；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputCompression＝{

　　  class＝NSNumber；

　　  default＝0.5；

　　  identity＝0.5；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputContrast＝{

　　  class＝NSNumber；

　　  default＝16；

　　  identity＝16；
				
				<dp n="d62"/>
　　  minimum＝0；

　　  sliderMaximum＝20；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputEndAngle＝{

　　  class＝NSNumber；

　　  default＝2.6；

　　  identity＝2.6；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputScale＝{

　　  class＝NSNumber；

　　  default＝126；

　　  identity＝126；

　　  minimum＝1；

　　  sliderMaximum＝200；

　　  sliderMinimum＝1；

　　  type＝scalar；

　　}；

　　inputStartAngle＝{

　　  class＝NSNumber；

　　  default＝1.1；

　　  identity＝1.1；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputTargetImage＝{class＝CIImage；}；

　　inputTime＝{ 

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝1；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝time；

　　}；

　　name＝Mod；

　　outputImage＝{class＝CIImage；}；
				
				<dp n="d63"/>
}
-------------Filter # 21：CICopyMachineTransition-------------{

　　category＝Transition；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputColor＝{class＝CIColor；default＝＜0.6，1，0.8，1＞；type＝
opaqueColor；}；

　　inputImage＝{class＝CIImage；}；

　　inputLeadingEdge＝{

　　  class＝NSNumber；

　　  default＝0.83；

　　  identity＝0.83；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputOpacity＝{

　　  class＝NSNumber；

　　  default＝1.3；

　　  identity＝1.3；

　　  minimum＝0；

　　  sliderMaximum＝3；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputRetumTime＝{

　　  class＝NSNumber；

　　  default＝0.65；

　　  identity＝0.65；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputTargetImage＝{class＝CIImage；}；

　　inputTime＝{
				
				<dp n="d64"/>
　　  class＝NSNumber；

　　  default＝0；
　　  identity＝0；

　　  maximum＝1；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；
　　  type＝time；

　　}；

　　inputWidth＝{

　　  class＝NSNumber；

　　  default＝200；

　　  identity＝200；

　　  minimum＝0.1；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0.1；

　　  type＝distance；

　　}；

　　name＝″Copy Machine″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 22：CIZoomBlurTransition-------------{

　　category＝Transition；

　　inputAmount＝{

　　  class＝NSNumber；

　　  default＝65；

　　  identity＝65；

　　  minimum＝0；

　　  sliderMaximum＝100；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputSampling＝{

　　  class＝NSNumber；

　　  default＝0.997；

　　  identity＝0.997；

　　  minimum＝0.01；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0.98；

　　  type＝scalar；

　　}；

　　inputTargetImage＝{class＝CIImage；}；
				
				<dp n="d65"/>
　　inputTime＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝1；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝time；

　　}；

　　name＝″Zoom Blur Transition″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 23：CIBumpDistortion-------------
{

　　category＝Distortion；

　　inputAmount＝{

　　  class＝NSNumber；

　　  default＝300；

　　  identity＝300；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputScale＝{

　　  class＝NSNumber；

　　  default＝-0.5；

　　  identity＝0；

　　  minimum＝-10；

　　  sliderMaximum＝10；

　　  sliderMinimum＝-10；

　　  type＝scalar；

　　}；

　　name＝Bump；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 24：CIPullDistortion-------------
{

　　category＝Distortion；

　　inputAmount＝{
				
				<dp n="d66"/>
　　  class＝NSNumber；

　　  default＝300；

　　  identity＝300；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputLength＝{

　　  class＝NSNumber；

　　  default＝50；

　　  identitv＝0；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　name＝Pull；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 25；CILinearPullDistortion-------------{

　　category＝Distortion；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；
				
				<dp n="d67"/>
　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputOffsetAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputOffsetLength＝{

　　  class＝NSNumber；

　　  default＝50；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝300；

　　  identity＝300；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　name＝″Linear Pull″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 26：CILinearBumpDistortion-------------{

　　category＝Distortion；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；
				
				<dp n="d68"/>
　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝300；

　　  identity＝300；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputScale＝{

　　  class＝NSNumber；

　　  default＝0.5；

　　  identity＝1；

　　  minimum＝-10；

　　  sliderMaximum＝10；

　　  sliderMinimum＝-10；

　　  type＝scalar；

　　}；

　　name＝″Luear Bump″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 27：CIRippleDistortion-------------
{

　　category＝Distortion；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputHeight＝{

　　  class＝NSNumber；

　　  default＝30；

　　  identity＝0；

　　  minimum＝-50；

　　  sliderMaximum＝50；

　　  sliderMinimum＝-50；

　　  type＝distance；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝300；

　　  identity＝0；

　　  mininum＝-50；

　　  sliderMaximum＝950；
				
				<dp n="d69"/>
　　  sliderMinimum＝-50；
　　  type＝distance；

　　}；

　　inputWidth＝{

　　  class＝NSNumber；

　　  default＝40；

　　  identity＝40；

　　  minimum＝0；

　　  sliderMaximum＝100；

　　  sliderMinimum＝0：

　　  type＝distance；

　　}；

　　name＝Ripple；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 28：CISuperGelButton-------------
{

　　category＝Distortion；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝position；}；

　　inputColor＝{class＝CIColor；default＝＜0.6，0.8，1，1＞；type＝color；}；

　　inputDamping＝{

　　  class＝NSNumber；

　　  default＝2；

　　  identity＝2；

　　  minimum＝0；

　　  sliderMaximum＝3；

　　  sliderMminmum＝0；

　　  type＝scalar；
　　}；

　　inputDepressTime＝{

　　  class＝NSNumber；

　　  default＝0.27；

　　  identity＝0.27；

　　  minimum＝0.1；

　　  sliderMaximum＝3；

　　  sliderMinimum＝0.1；

　　  type＝scalar；

　　}；

　　inputExpansion＝{

　　  class＝NSNumber；

　　  default＝0.02；

　　  identity＝0；

　　  minimum＝-1；
				
				<dp n="d70"/>
　　  sliderMaximum＝1；

　　  sliderMminmum＝-1；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputPeriod＝{

　　  class＝NSNumber；

　　  default＝0.4；

　　  identity＝0.4；

　　  minimum＝0.1；

　　  sliderMaximum＝3；

　　  sliderMinimum＝0.1；

　　  type＝scalar；

　　}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝200；

　　  identity＝200；

　　  minimum＝1；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝1；

　　  type＝scalar；

　　}；

　　inputReflection＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝1；

　　  minimum＝0；

 　　 sliderMaximum＝3；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputRefraction＝{

　　  class＝NSNumber；

　　  default＝12；

　　  identity＝12；

　　  minimum＝0；

　　  sliderMaximum＝200；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputShineMap＝{class＝CIImage；}；

　　inputSlope＝{
　　  class＝NSNumber；

　　  default＝-4；

　　  identity＝-4；
				
				<dp n="d71"/>
      minimum＝-6.5；

      sliderMaximum＝4.5；

　　  sliderMinimum＝-6.5；

　　  type＝scalar；

　　}；

　　name＝″Super Gel Button″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 29：CIPinchDistortion-------------
{

　　category＝Distortion；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝300；

　　  idcntity＝0；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputScale＝{

　　  class＝NSNumber；

　　  default＝0.5；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　name＝Pinch；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 30：CIDisplaceDistortion-------------{

　　category＝Distortion；

　　inputDisplacement＝{

　　  class＝NSNumber；
　　  default＝600；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝10000；

　　  sliderMinimum＝0；
				
				<dp n="d72"/>
　　  type＝distance；

　　}；

　　inputDisplacementMap＝{class＝CIImage；}；

　　inputImage＝{class＝CIImage；}；

　　name＝Displace；
　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 31；CIRoundedDistortion-------------
{

　　category＝Distortion；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝position；}；

　　inputImage＝{class＝CIImage；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝400；

　　  identity＝400；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　name＝Rounded；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 32；CIFunHouseDistortion-------------{

　　category＝Distortion；

　　inputAmount＝{

　　  class＝NSNumber；

　　  default＝3；

　　  identity＝1；

　　  minimum＝0；
　　  sliderMaximum＝100；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　  sliderMinimum＝0；
				
				<dp n="d73"/>
　　  type＝angle；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImagc；}；

　　inputWidth＝{

　　  class＝NSNumber；

　　  default＝400；

　　  identity＝400；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0：

　　  type＝distance；

　　}；

　　name＝″Fun House″：

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 33：CIBlackHoleDistortion-------------{

　　category＝Distortion；

　　inputAmount＝{

　　  class＝NSNumber；

　　  default＝150；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　name＝″Black Hole″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 34：CIHoleDistortion-------------
{

　　category＝Distortion；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝150；

　　  identity＝0.1；
				
				<dp n="d74"/>
　　  minimum＝0.01；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0.01；

　　  type＝distance；

　　}；

　　name＝Hole；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 35：CIAffineTile-------------
{

　　category＝Distortion；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputScale＝{
　　  class＝NSNumber；

　　  default＝3；

　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝20；

　　  sliderMinimum＝0.05；

　　  type＝scalar；

　　}；
　　inputSkew＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  sliderMaximum＝3；

　　  sliderMinimum＝-3；

　　  type＝scalar；

　　}；

　　inputStretch＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝1；
				
				<dp n="d75"/>
　　  minimum＝0；

　　  sliderMaximum＝10；

　　  sliderMinimum＝0.1；

　　  type＝scalar；

　　}；

　　name＝″Affine Tile″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 36：CIOpTile-------------
{

　　category＝Distortion；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝6.283185307179586；
　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputScale＝{

　　  class＝NSNumber；

　　  default＝2.8；

　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝10；

　　  sliderMinimum＝0.1；
　　  type＝scalar；

　　}；

　　inputTileSize＝{

　　  class＝NSNumber；

　　  default＝65；

　　  identity＝65；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝1；

　　  type＝distance；

　　}；

　　name＝″Op Tile″；

　　outputImage＝{class＝CIImage；}；
}
				
				<dp n="d76"/>
-------------Filter # 37：CIParallelogramTile-------------
{

　　category＝Distortion；

　　inputAcuteAngle＝{

　　  class＝NSNumber；

　　  default＝1.570796326794897；

　　  identity＝1.570796326794897；
　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　  　identity＝0；

　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputTileSize＝{

　　  class＝NSNumber；

　　  default＝100；

　　  identity＝100；

　　  minimum＝0；

　　  sliderMaximum＝200；

　　  slidcrMinimum＝1；

　　  type＝distance；

　　}；

　　name＝″Parallelogram Tile；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 38：CITriangleTile-------------
{

　　category＝Distortion；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0；
				
				<dp n="d77"/>
　　  identity＝0；

　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  typc＝angle；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
positiotn；}；
　　inputImage＝{class＝CIImage；}；

　　inputTileSize＝{

　　  class＝NSNumber；

　　  default＝100；

　　  identity＝100；

　　  ninimum＝0；

　　  sliderMaximum＝200；

　　  sliderMinimum＝1；

　　  type＝distance；

　　}；

　　name＝″Triangle Tile；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 39：CIGlassDistortion-------------
{

　　category＝Distortion；

　　inputAmount＝{

　　  class＝NSNumber；

　　  default＝110；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝2000；

　　  sliderMinimum＝0.01；

　　  type＝distance；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputScale＝{

　　  class＝NSNumber；

　　  default＝0.4；

　　  identitv＝1；

　　  minimum＝0.001；
　　  sliderMaximum＝2；

　　  sliderMinimum＝0.004；

　　  type＝distance；
				
				<dp n="d78"/>
　　}；

　　inputSoftness＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝5；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputTexture＝{class＝CIImage；}；

　　name＝″Glass Distortion″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 40：CIRingLens-------------
{

　　category＝Distortion；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝20；

　　  identity＝20；

　　  minimum＝0.01；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0.01；

　　  type＝distance；

　　}；

　　inputRefraction＝{

　　  class＝NSNumber；

　　  dcfault＝1；

　　  identity＝0；

　　  minimum＝0.0001；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0.0001；

　　  type＝scalar；

　　}；

　　name＝″Ring Lens″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 41：CIStarburst--------------
{

　　category＝Distortion；
				
				<dp n="d79"/>
　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputRadius＝{

　  class＝NSNumber；

　　  default＝300；
　　  identity＝300；

　　  minimum＝0.01；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0.01；

　　  type＝distance；

　　}；

　　name＝Starburst；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 42：CITorusLens-------------
{

　　category＝Distortion；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝160；

　　  identity＝160；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputRefraction＝{

　　  class＝NSNumber；

　　  default＝1.7；

　　  identity＝0；

　　  minimum＝-5；

　　  sliderMaximum＝5；

　　  sliderMinimum＝-5；

　　  type＝scalar；

　　}；

　　inputSymmctricRefraction＝{class＝NSNumber；default＝0；identity
＝0；type＝boolean；}；

　　inputThickness＝{

　　  class＝NSNumber；

　　  default＝0.43；

　　  identity＝0.43；
				
				<dp n="d80"/>
　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　name＝″Torus Lens″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 43：CIGlassLozenge-------------
{

　　category＝Distortion；

　　inputImage＝{class＝CIImage；}；

　　inputPoint0＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputPoint1＝{class＝CIVector；default＝＜350，150，0，1＞；type＝
position；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝100；

　　  identity＝100；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputRefraction＝{

　　  class＝NSNumber；

　　  default＝30；

　　  identity＝0；

　　  minimum＝-100；

　　  sliderMaximum＝200；

　　  sliderMinimum＝-100；

　　  type＝scalar；

　　}；

　　name＝″Glass Lozenge″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 44；CITwirlDistortion-------------
{

　　category＝Distortion；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；
				
				<dp n="d81"/>
　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝500；

　　  sliderMinimum＝-500；

　　  type＝angle；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputGradualAngles＝{class＝NSNumber；default＝0；identity＝0；
type＝boolean；}；

　　inputImage＝{class＝CIImage；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝500；

　　  identity＝500；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputVortex＝{class＝NSNumber；default＝0；identity＝0；type＝
boolean；}；

　　name＝Twirl；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 45：CIFlagWaveDistortion-------------{

　　category＝Distortion；

　　inputDroop＝{

　　  class＝NSNumber；

　　  default＝0.5；

　　  identity＝0.5；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputRippleAmplitude＝{

　　  class＝NSNumber；

　　  default＝25；

　　  identity＝25；

　　  minimum＝0；

　　  sliderMaximum＝120；

　　  sliderMinimum＝0；

　　  type＝distance；
				
				<dp n="d82"/>
　　}；

　　inputRippleWavelength＝{

　　  class＝NSNumber；

　　  default＝280；

　　  identity＝280；

　　  minimum＝10；

　　  sliderMaximum＝600；

　　  sliderMinimum＝10；

　　  type＝distance；

　　}；

　　inputRippleY＝{

　　  class＝NSNumber；

　　  default＝0.3；

　　  identity＝0.3；

　　  minimum＝0；
　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputXPhase＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputXWidth＝{

　　  class＝NSNumber；

　　  default＝200；

　　  identity＝200；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　name＝″Flag Wave″；

　　outputImagc＝{class＝CIImage；}；
}
-------------Filter # 46；CIPerspectiveTile-------------
{

　　category＝Distortion；

　　inputBottomLeft＝{class＝CIVector；default＝＜118，484，0，1＞；
type＝position；}；
				
				<dp n="d83"/>
    inputBottomRight＝{class＝CIVector；default＝＜646，507，0，1＞；type＝position；}；

　　inputImage＝{class＝CIImage；}；

　　inputTopLeft＝{class＝CIVector；default＝＜155，153，0，1＞；type＝position；}；

　　inputTopRight＝{class＝CIVector；default＝＜548，140，0，1＞；type＝position；}；

　　name＝″Perspective Tile″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 47：CISphereDistortion-------------
{

　　category＝Distortion；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝300；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　name＝Sphere；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 48：CIAffineTransform-------------
{

　　category＝Distortion；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMmimum＝0；

　　  type＝angle；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputScale＝{
				
				<dp n="d84"/>
　　  class＝NSNumber；

　　  default＝3；

　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝20；

　　  sliderMinimum＝0.05；
　　  type＝scalar；

　　}；

　　inputSkew＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  sliderMaximum＝3；

　　  sliderMinimum＝-3；

　　  type＝scalar；

　　}；

　　inputStretch＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝10；

　　  sliderMinimum＝0.1；

　　  type＝scalar；

　　}；

　　name＝″Affine Transform″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 49：CICircularRippleGlassDistortion
-------------
{

　　category＝Distortion；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputForeshortening＝{

　　  class＝NSNumber；
 　　 default＝1.6；

　　  identity＝1；

　　  minimum＝0.25；

　　  sliderMaximum＝4；

　　  sliderMinimum＝0.25；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImagc；}；

　　inputPhase＝{
				
				<dp n="d85"/>
　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝0；
　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputRefraction＝{

　　  class＝NSNumber；

　　  default＝100；

　　  identity＝100；

　　  minimum＝0；

　　  sliderMaximum＝200；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputWavelength＝{

　　  class＝NSNumber；

　　  default＝100；

　　 identity＝100；

 　　 minimum＝0.1；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0.1；

　　  type＝distance；

　　}；

　　name＝″Circular Ripple Glass″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 50：CILinearRippleGlassDistortion-------------{

　　category＝Distortion；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　 maximum＝6.283185307179586；　

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputRefraction＝{
				
				<dp n="d86"/>
　　  class＝NSNumber；

　　  default＝100；

　　  identity＝100；

　　  minimum＝0；

　　  sliderMaximum＝200；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputWavelength＝{

　　  class＝NSNumber；

　　  default＝100；

　　  identity＝100；

　　  minimum＝0.1；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0.1；

　　  type＝distance；

　　}；

　　name＝″Linear Ripple Glass″；

　　outputImage＝{class＝CIImage；}；
}
-------------Fiter#51：CISuperGlassLozengeDistortion-------------{

　　category＝Distortion；

　　inputColor＝{class＝CIColor；default＝＜1，1，1，1＞；type＝
opaqueColor；}；

　　inputImage＝{class＝CIImage；}；

　　inpurPoint0＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputPoint1＝{class＝CIVector；default＝＜350，150，0，1＞；type＝
position；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝100；

　　  identity＝100；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMininum＝0；

　　  type＝distance；

　　}；

　　inputReflection＝{

　 　 class＝NSNumber；

　　  default＝1；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝2；

　　  sliderMinimum＝0；
				
				<dp n="d87"/>
      type＝scalar；

　　}；

　　inputRefraction＝{

　　  class＝NSNumber；

　　  default＝6；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝200；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputShineMap＝{class＝CIImage；}；

　　name＝″Super Glass Lozenge″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 52：CIPerspective-------------
{

　　category＝Distortion；

　　inputBottomLeft＝{class＝CIVector；default＝＜118，484，0，1＞；
type＝position；}；

　　inputBottomRight＝{class＝CIVector；default＝＜646，507，0，1＞；
type＝position；}；

　　inputImage＝{class＝CIImage；}；

　　inputTopLeft＝{class＝CIVector；default＝＜155，153，0，1＞；type
＝position；}；

　　inputTopRight＝{class＝CIVector；default＝＜548，140，0，1＞；type
＝position；}；

　　name＝Perspective；
　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 53：CIInsideOutDistortion-------------{
　　category＝Distortion；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝150；

　　  identity＝0.1；

　　  minimum＝0；

　　  sliderMaximum＝1000；
　　  sliderMinimum＝0；

　　  type＝dtstance；

　　}；
				
				<dp n="d88"/>
　　name＝″Inside Out″；
　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 54：CICircleSplashDistortion-------------{

　　category＝Distortion；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inutImage＝{class＝CIImage；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝150；

　　  identity＝0.1；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　name＝″Circle Splash″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 55：CIKcystoneDistortion-------------{

　　category＝Distortion；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputScale＝{

　　  class＝NSNumber；

　　  default＝0.5；

　　  identity＝0.5；

　　  minimum＝0.01；

　　  sliderMaximum＝10；

　　  sliderMinimum＝0.01；

　　  type＝distance；

　　}；

　　inputYBottom＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputYTop＝{
				
				<dp n="d89"/>
　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝0；
　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　name＝Keystone；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 56：CIColorAxialGradient-------------{

　　category＝Generator；

　　inputColor1＝{class＝CIColor；default＝＜1，0.9，0.8，1＞；type＝
color；}；

　　inputColor2＝{class＝CIColor；default＝＜0.5，0.1，0，1＞；type＝
color；}；

　　inputPoint1＝{class＝CIVector；default＝＜0，0，0，1＞；type＝
position；}；

　　inputPoint2＝{class＝CIVector；default＝＜200，200，0，1＞；type＝
position；}；

　　name＝″Color Axial Gradient″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 57：CIColorRadialGradient-------------{

　　category＝Generator；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputColor1＝{class＝CIColor；default＝＜1，0.9，0.8，1＞；type＝
color；}；

　　inputColor2＝{class＝CIColor；default＝＜0.5，0.1，0，1＞；type＝
color；}；

　　inputRadius0＝{

　　  class＝NSNumber；

　　  default＝5；

　　  identity＝5；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；
　　inputRadius1＝{

　　  class＝NSNumber；

　　  default＝100；
				
				<dp n="d90"/>
　　  identity＝100；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　name＝″Color Radial Gradient″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 58：CIAxialGradient-------------
{

　　category＝Generator；

　　inputGradientImage＝{class＝CIImage；type＝gradient；}；

　　inputPoint1＝{class＝CIVector；default＝＜0，0，0，1＞；type＝
position；}；

　　inputPoint2＝{class＝CIVector；default＝＜200，200，0，1＞；type＝
position；}；

　　name＝″Axial Gradient″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 59：CIRadialGradient--------------
{

　　category＝Generator；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputGradientImage＝{class＝CIImage；type＝gradient；}；

　　inputRadius0＝{

　　  class＝NSNumber；

　　  default＝5；

　　  identity＝5；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；
　　  type＝distance；

　　}；

　　inputRadius1＝{

　　  class＝NSNumber；

　　  default＝100；

　　  identity＝100；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；
				
				<dp n="d91"/>
　　name＝″Radial Gradient″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 60；CIGaussianGradient-------------
{

　　category＝Generator；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputColor＝{class＝CIColor；default＝＜1，0.9，0.8，1＞；type＝
color；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝300；

　　  identity＝300；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　name＝″Gaussian Gradient″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 61：ClCheckerboardGenerator-------------{

　　category＝Generator；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputColor1＝{class＝CIColor；default＝＜1，0.9，0.8，1＞；type＝
color；}；

　　inputColor2＝{class＝CIColor；default＝＜0.5，0.1，0，1＞；type＝
color；}；

　　inputCointrast＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputWidth＝{

　　  class＝NSNumber；

　　  default＝80；

　　  identity＝80；

　　  minimum＝0；
				
				<dp n="d92"/>
　　  sliderMaximum＝800；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　name＝Checkerboard；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 62：CIStripesGenerator-------------
{

　　category＝Generator；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputColor1＝{class＝CIColor；default＝＜1，0.9，0.8，1＞；type＝
color；}；

　　inputColor2＝{class＝CIColor；default＝＜0.5，0.1，0，1＞；type＝
color；}；

　　inputContrast＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputWidth＝{

　　  class＝NSNumber；

　　  default＝80；

　　  identity＝80；

　　  minimum＝0；

　　  slidcrMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　name＝Stripes；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 63：CIOpArtlGenerator-------------
{

　　category＝Generator；

　　inputAmplitude＝{

　　  class＝NSNumber；

　　  default＝18；

　　  identity＝18；
				
				<dp n="d93"/>
　　  minimum＝0.1；

　　  sliderMaximum＝500；
　　  sliderMinimum＝0.1；

　　  type＝distance；

　　}；

　　inputContrast＝{

　　  class＝NSNumber；

　　  default＝3.12；

　　  identity＝3.12；

　　  minimum＝0.1；
　　  sliderMaximum＝10；

　  sliderMinimum＝0.1；
　　  type＝scalar；

　　}；

　　inputLueThickness＝{

　  　class＝NSNumber；

　　  default＝3.64；

　　  identity＝3.64；

　　  minimum＝0；

　　  sliderMaximum＝10；

　　  sliderMinimum＝0；

　  　type＝distance；

　　}；

　　inputRoundness＝{

　　  class＝NSNumber；

　　  default＝0.07000000000000001；

　　  identity＝0.07000000000000001；
　　  minimum＝-0.11；

　　  sliderMaximum＝0.7；

　　  sliderMininum＝-0.11；

　　  type＝distance；

　　}；

　　inputWavelength1＝{

　　  class＝NSNumber；

　　  default＝700；

　　  identity＝700；

　　  minimum＝2；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝2；

　　  type＝distance；

　　}；

　　inputWavelength2＝{

　　  class＝NSNumber；

　　  default＝140；

　　  identity＝140；
　　  minimum＝2；
				
				<dp n="d94"/>
　　  sliderMaximun＝1000；

　　  sliderMinimum＝2；

　　  type＝distance；
　　}；
　　name＝″Op Art 1″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 64；CIOpArt2Generator-------------
{

　　category＝Generator；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputCompression＝{

　　  class＝NSNumber；

　　  default＝0.71；

　　  identity＝0.71；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputCointrast＝{

　　  class＝NSNumber；

　　  default＝3.8；

　　  identity＝3.8；
　　  minimum＝0；

　　  sliderMaximum＝20；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputRadius＝{

　　  class＝NSNumber；
　　  default＝0.6；

　　  identity＝0.6；

　　  minimum＝0；

　　  sliderMaximum＝1.5；

　　  sliderMinimum＝0；
				
				<dp n="d95"/>
　　  type＝scalar；

　　}；

　　inputScale＝{

　　  class＝NSNumber；
　　  default＝80；

　　  identity＝80；

　　  minimum＝1；

　　  sliderMaximum＝200；

　　  sliderMinimum＝1；

　　  type＝scalar；

　　}；

　　name＝″Op Art 2″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 65；CIOpArt3Generator-------------
{

　　category＝Generator；

　　inputAmplitude＝{

　　  class＝NSNumber；

　　  default＝16；

　　  identity＝16；

　　  minimum＝0.1；

　　  sliderMaximum＝500；

　　  sliderMinimum＝0.1；

　　  type＝scalar；

　　}；

　　inputContrast＝{

　　  class＝NSNumber；

　　  default＝4；

　　  identity＝4；

　　  minimum＝0.1；

　　  sliderMaximum＝10；

　　  sliderMinimum＝0.1；

　　  type＝scalar；
　　}；

　　inputLineThickness＝{

　　  class＝NSNumber；

　　  default＝5.4；

　　  identity＝5.4；

　　  minimum＝0；

　　  sliderMaximum＝10；

　　  sliderMininum＝0；

　　  type＝distance；

　　}；

　　inputRoundness＝{
				
				<dp n="d96"/>
　　  class＝NSNumber；

　　  default＝0.12；

　　  ideutity＝0.12；

　　  minimum＝-0.11；

　　  sliderMaximum＝0.7；

　　  sliderMinimum＝-0.11；

　　  type＝distance；
　　}；

　　inputSkew＝{

　　  class＝NSNumber；

　　  default＝2.28；

　　  identity＝2.28；

　 　 minimum＝0；

　　  sliderMaximum＝10；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputWavelength＝{

　　  class＝NSNumber；

　　  default＝314；

　　  identity＝314；

　　  minimum＝2；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝2；

　　  type＝distance；

　　}；

　　name＝″Op Art 3″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 66；CIStarShineGenerator-------------{

　　category＝Generator；
　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；typc＝
position；}；
　　inputColor＝{class＝CIColor；default＝＜1，0.8，0.6，1＞；type＝
color；}；

　　inputCrossAngle＝{

　　  class＝NSNumber；

　　  default＝0.6；

　　  identity＝0.6；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputCrossOpacity＝{
				
				<dp n="d97"/>
　　  class＝NSNumber；

　　  default＝-2；

　　  identity＝-2；

　　  minimum＝-8；

　　  sliderMaximum＝0；

　　  sliderMinimum＝-8；

　　  type＝scalar；

　　}；

　　inputCrossScale＝{

　　  class＝NSNumber；

　　  default＝15；

　　  identity＝15；

　　  minimum＝0；

　　  sliderMaximum＝100；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputCrossWidth＝{

　　  class＝NSNumber；

　　  default＝2.5；

　　  identity＝2.5；

　　  minimum＝0；

　　  sliderMaximum＝300；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputEpsilon＝{

　　  class＝NSNumber；

　　  default＝-2；

　　  identity＝-2；

　　  minimum＝-8；

　　  sliderMaximum＝0；

　　  sliderMinimum＝-8；

　　  type＝scalar；

　　}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝50；

　　  identity＝50；

　　  minimum＝0；

　　  sliderMaximum＝300；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　name＝″Star Shine″；

　　outputImage＝{class＝CIImage；}；
				
				<dp n="d98"/>
}
-------------Fiter # 67：CILenticularHaloGenerator-------------{

　　category＝Generator；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputColor＝{class＝CIColor；default＝＜1，0.9，0.8，1＞；type＝
color；}；

　　inputHaloOverlap＝{

　　  class＝NSNumber；

　　  default＝0.77；

　　  minimum＝O；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  typc＝scalar；

　　}；

　　inputHaloRadius＝{

　　  class＝NSNumber；

　　  default＝70；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputHaloWidth＝{

　　  class＝NSNumber；

　　  default＝87；

　　  minimum＝0；

　　  sliderMaximum＝300；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputLookupRadius＝{

　　  class＝NSNumber；

　　  default＝100；

　　  minimum＝0；

　　  sliderMaximum＝330；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputStriationContrast＝{

　　  class＝NSNumber；

　　  default＝1；

　　  minimum＝0；

　　  sliderMaximum＝5；
				
				<dp n="d99"/>
　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputStriationStrength＝{

　　  class＝NSNumber；

　　  default＝0.5；

　　  minimum＝0；

　　  sliderMaximum＝3；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputTexture＝{class＝CIImage；}；

　　name＝″Lenticular Halo″；

　　outputImage＝{class＝CIImage；}；
}
    -------------Filter # 68；CIFloodGenerator-------------
{
    category＝Generator；

    inputColor＝{class＝CIColor；default＝＜1，0，0，1＞；type＝
color；}；

    name＝Flood；

    outputImage＝{class＝CIImage；}；
}
-------------Filter # 69：CISunbeams-------------
{

　　category＝Generator；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputColor＝{class＝CIColor；default＝＜1，0.8，0.6，1＞；type＝
color；}；

　　inputImage＝{class＝CIImage；}；

　　inputLookupRadius＝{

　　  class＝NSNumber；

　　  default＝45；

　　  identity＝45；

　　  minimum＝0；

　　  sliderMaximum＝330；

　　  sliderMinimum＝0；

　　  type＝distanee；

　　}；

　　inputMaxStriationRadius＝{

　　  class＝NSNumber；

　　  default＝2.58；

　　  identity＝2.58；
				
				<dp n="d100"/>
      minimum＝0；

　　  sliderMaximum＝10；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputStriationContrast＝{

　　  class＝NSNumber；

　　  default＝1.375；
　　  idcntity＝1.375；

　　  minimum＝0；

　　  sliderMaximum＝5；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputStriationStrength＝{

　　  class＝NSNumber；

　　  default＝0.5；

　　  identity＝0.5；

　　  minimum＝0；

　　  sliderMaximum＝3；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputSunRadius＝{

　　  class＝NSNumber；

　　  default＝40；

　　  identity＝40；

　　  minimum＝0；

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputTexture＝{class＝CIImage；}；

　　name＝Sunbeams；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 70；CIGammaTestImageGenerator-------------{category＝Generator；

    name＝″Gamma Test Image″；

    outputImage＝{class＝CIImage；}；
}
-------------Filter # 71：CISharpen-------------
{

　　category＝Focus；
				
				<dp n="d101"/>
　　inputImage＝{class＝CIImage；}；

　　inputIntensity＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝2；

　　  sliderMiniuum＝0；

　　  type＝scalar；

　　}；

　　inputLuminanceOnly＝{class＝NSNumber；default＝0；identity＝0；
type＝boolean；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝2.5；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝100；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　name＝Sharpen；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 72：CISharpenEdges-------------
{

　　category＝Focus；

　　inputEdgeScale＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝10；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputEdgeThreshold＝{

　　  class＝NSNumber；

　　  default＝0.12；

　　  identity＝0.12；

　　  minimum＝0；

　　  sliderMaximum＝40；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；
				
				<dp n="d102"/>
　　inputImage＝{class＝CIImage；}；

　　inputIntensity＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝2；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  dcfault＝2.5；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝100；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　name＝″Sharpen Edges″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 73：CIHalftone-------------
{

　　category＝Stylize；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0.7853981633974483；

　　  identity＝0.7853981633974483；

　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputContrast＝{

　　  class＝NSNumber；

　　  default＝3.33；

　　  identity＝1；

　　  minimum＝1；

　　  sliderMaximum＝30；

　　  sliderMinimum＝1；

　　  type＝scalar；
				
				<dp n="d103"/>
　　}；

　　inputImage＝{class＝CIImage；}；

　　inputScale＝{

　　  class＝NSNumber；

　　  default＝6；

　　  identity＝6；

　　  minimum＝2；

　　  sliderMaximum＝100；

　　  sliderMinimum＝2；

　　  type＝distance；

　　}；

　　name＝Halftone；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 74：CILineScreen-------------
{

　　category＝Stylize；

　　iuputAngle＝{

　　  class＝NSNumber；

　　  default＝0.5；

　　  identity＝0；

　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  slidcrMinimum＝0；

　　  typc＝angle；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputContrast＝{

　　  class＝NSNumber；

　　  default＝0.5；

　　  identity＝0.5；

　　  minimum＝0.001；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0.001；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputScale＝{

　　  class＝NSNumber；

　　  default＝-0.7；

　　  identity＝-0.7；

　　  minimum＝-3；

　　  sliderMaximum＝-0.477122；
				
				<dp n="d104"/>
　　  sliderMinimum＝-3；

　　  type＝distance；

　　}；

　　inputSkew＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝-3；

　　  slidcrMaximum＝3；

　　  sliderMinimum＝-3；

　　  type＝scalar；

　　}；

　　inputStretcb＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝-2；

　　  sliderMaximum＝2；

　　  sliderMinimum＝-2；

　　  type＝scalar；

　　}；

　　name＝Line Screen″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 75：CIHatchedScreen-------------
{

　　category＝Stylize；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0.5；

　　  identity＝0；

　　  maximum＝6.283185307179586；

　　  mininum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputContrast＝{

　　  class＝NSNumber；

　　  default＝0.5；

　　  identity＝0.5；

　　  minimum＝0.001；

　　  sliderMaximum＝1；
				
				<dp n="d105"/>
　　  sliderMinimum＝0.001；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputScale＝{

　　  class＝NSNumber；

　　  default＝-0.7；

　　  identity＝0；

　　  minimum＝-3；

　　  sliderMaximum＝-0.477122；

　　  sliderMinimum＝-3；

　　  type＝distance；

　　}；

　　inputSkew＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝-3；

　　  sliderMaximum＝3；

　　  sliderMinimum＝-3；

　　  type＝scalar；

　　}；

　　inputStretch＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝-2；

　　  sliderMaximum＝2；

　　  sliderMinimum＝-2；

　　  type＝scalar；

　　}；

　　name＝″Hatched Screen″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 76；CIWavyScreen-------------
{

　　category＝Stylize；

　　inputAmplitude＝{

　　  class＝NSNumber；

　　  default＝40；

　　  identity＝40；

　　  minimum＝0；

　　  sliderMaximum＝100；

　　  sliderMinimum＝0；

　　  type＝distance；
				
				<dp n="d106"/>
　　}；

　　inputContrast＝{

　　  class＝NSNumber；

　　  default＝0.75；

　　  identity＝0.75；

　　  minimum＝0.001；

　　  slidcrMaximum＝1；

　　  sliderMinimum＝0.001；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputScale＝{

　　  class＝NSNumber；

　　  default＝5；

　　  identity＝5；

　　  minimum＝0.001；

　　  sliderMaximum＝200；

　　  sliderMinimum＝0.001；

　　  type＝distance；

　　}；

　　inputWavelength＝{

　　  class＝NSNumber；

　　  default＝125；

　　  identity＝125；

　　  minimum＝0.001；

　　  sliderMaximum＝500；

　　  sliderMinimum＝0.001；

　　  type＝distance；

　　}；

　　name＝″Wavy Screen″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 77：CICircularScreen-------------
{

　　category＝Stylize；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputContrast＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝1；

　　  minimum＝0.001；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0.001；

　　  type＝scalar；
				
				<dp n="d107"/>
　　}；

　　inputImage＝{class＝CIImage；}；

　　inputScalc＝{

　　  class＝NSNumber；

　　  default＝-0.7；

　　  identity＝-0.7；

　　  minimum＝-3；

　　  sliderMaxiynum＝-0.477122；

　　  sliderMinimum＝-3；

　　  type＝scalar；

　　}；

　　name＝″Circular Screen″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 78：CITextureScreen-------------
{

　　category＝Stylize；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputImageContrast＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝20；
　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputMapImage＝{class＝CIImage；}；

　　inputNoiseContrast＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝1；

　　  minimum＝0；
				
				<dp n="d108"/>
　　  sliderMaximum＝20；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputNoisiness＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝20；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputScale＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝-2；

　　  sliderMaximum＝2；

　　  sliderMinimum＝-2；

　　  type＝distance；

　　}；
　　inputSkew＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝-3；

　　  sliderMaximum＝3；

　　  sliderMinimum＝-3；

　　  type＝scalar；

　　}；

　　inputStretch＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝-2；

　　  sliderMaximum＝2；

　　  sliderMinimum＝-2；

　　  type＝scalar；

　　}；

　　inputThreshold＝{

　　  class＝NSNumber；

　　  default＝0.5；

　　  identity＝0.5；

　　  minimum＝-2；

　　  sliderMaximum＝2；
				
				<dp n="d109"/>
　　  sliderMinimum＝-2；
　　  type＝scalar；

　　}；

　　name＝″Texture Screen″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 79：CIPixellate-------------
{

　　category＝Stylize；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIUmage；}；

　　inputScale＝{

　　  class＝NSNumber；

　　  default＝8；

　　  identity＝1；

　　  minimum＝1；

　　  sliderMaximum＝100；

　　  sliderMinimum＝1；
　　  type＝distance；

　　}；

　　name＝Pixellate；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 80：CIOverdriveGlow-------------
{

　　category＝Stylize；

　　inputAlphaSoftness＝{

　　  class＝NSNumber；

　　  default＝0.2；

　　  identity＝0.2；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputGlowOpacity＝{

　　  class＝NSNumber；

　　  default＝1.5；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝3；

　　  sliderMinimum＝0；
　　  type＝scalar；
				
				<dp n="d110"/>
　　}；

　　inputGlowRadius＝{

　　  class＝NSNumber；

　　  default＝10；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝100；
　　  sliderMinimum＝0；
　   type＝distance；

    }；

　　inputImage＝{class＝CIImage；}；

　　inputTbreshold＝{

　　  class＝NSNumber；

　　  default＝0.75；

　　  identity＝0.75；

　　  minimum＝0；

　　  slidcrMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　name＝″Overdrive Glow″；

　　utputImage＝{class＝CIImage；}；
}
-------------Filter # 81：CIHighpass-------------
{

　　category＝Stylize；

　　inputAmount＝{

　　  class＝NSNumber；

　　  default＝15；

　　  identity＝15；

　　  minimum＝0；

　　  sliderMaximum＝30；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝10；

　　  identity＝10；

　　  minimum＝0；

　　  sliderMaximum＝100；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；
				
				<dp n="d111"/>
　　name＝Highpass；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 82：CIBloom-------------
{

　　category＝Stylize；

　　inputAmount＝{

　　  class＝NSNumber；

　　  default＝1；

　　  minimum＝0；

　　  sliderMaximum＝2；

　　  sliderMinimum＝0；

　　  typc＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝10；

　　  minimum＝0；

　　  sliderMaximum＝100；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　name＝Bloom；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 83：CIGloom-------------
{

　　category＝Stylize；

　　inputAmount＝{

　　  class＝NSNumber；

　　  default＝1；

　　  minimum＝0；

　　  sliderMaximum＝2；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝10；

　　  minimum＝0；

　　  sliderMaximum＝100；

　　  sliderMinimum＝0；
				
				<dp n="d112"/>
　　  type＝distance；

　　}；

　　name＝Gloom；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 84：CIEdges-------------
{

　　category＝Stylize；

　　inputImage＝{class＝CIImage；}；

　　inputIntensity＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝50；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　name＝Edges；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 85：CIEdgeWork-------------
{

　　category＝Stylize；

　　inputAmount＝{

　　  class＝NSNumber；

　　  default＝15；

　　  minimum＝0；

　　  sliderMaximum＝30；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputBlur＝{

　　  class＝NSNumber；

　　  default＝3；

　　  minimum＝0；

　　  sliderMaximum＝3.5；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝10；
				
				<dp n="d113"/>
　　  minimum＝0；

　　  sliderMaximum＝100；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputSmoothness＝{

　　  class＝NSNumber；

　　  default＝1；

　　  minimum＝0；

　　  sliderMaximum＝5；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　name＝″Edge Work″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 86：CIGradientLookupTable-------------{

　　category＝Stylize；

　　inputBias＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputTexture＝{class＝CIImage；}；

　　name＝″Gradient Lookup Table″；

　　outputInage＝{class＝CIImage；}；
}
-------------Filter # 87：CICMYKHalftone-------------
{

　　category＝Stylize；

　　inputBlackAngle＝{

　　  class＝NSNumber；

　　  default＝0.7853981633974483；
　　  identity＝0.7853981633974483；

　　  minimum＝-3.141592653589793；

　　  sliderMaximum＝3.141592653589793；

　　  sliderMinimum＝-3.141592653589793；

　　  type＝angle；

　　}；
				
				<dp n="d114"/>
　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputContrast＝{

　　  class＝NSNumber；

　　  default＝5.62；

　　  identity＝5.62；

　　  minimum＝1；

　　  sliderMaximum＝30；

　　  sliderMinimum＝1；

　　  type＝scalar；

　　}；

　　inputCyanAagle＝{

　　  class＝NSNumber；

　　  default＝1.308996938995747；

　　  identity＝1.308996938995747；

　　  minimum＝-3.141592653589793；

　　  sliderMaximum＝3.141592653589793；

　　  sliderMinimum＝-3.141592653589793；

　　  type＝angle；

　　}；

　　inputGamma＝{

　　  class＝NSNumber；

　　  default＝1.8；

　　  identity＝1.8；

　　  minimum＝0.316；

　　  sliderMaximum＝3.162；

　　  sliderMinimum＝0.316；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputMagentaAngle＝{

　　  class＝NSNumber；

　　  default＝0.2617993877991494；

　　  identity＝0.2617993877991494；

　　  minimum＝-3.141592653589793；

　　  sliderMaximum＝3.141592653589793；

　　  sliderMmimum＝-3.141592653589793；

　　  type＝angle；

　　}；

　　inputScale＝{

　　  class＝NSNumber；

　　  dcfault＝6；

　　  identity＝6；

　　  minimum＝2；

　　  sliderMaximum＝100；

　　  sliderMinimum＝2；
				
				<dp n="d115"/>
　　  type＝distance；

　　}；

　　inputUCR＝{

　　  class＝NSNumber；

　　  default＝0.5；

　　  identity＝0.5；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputYellowAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝-3.141592653589793；

　　  sliderMaximum＝3.141592653589793；

　　  sliderMirimum＝-3.141592653589793；

  　　type＝angle；

　　}；

　　name＝″CMYK Halftone″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 88：CILayerPlusDropShadow-------------{

　　category＝Compositing；

　　inputImage＝{class＝CIImage；}；

　　inputLayer＝{class＝CIImage；}；

　　inputLayerOpacity＝{

　　  class＝NSNumber；

　　  default＝1；

　　  minimum＝0；

　　  sliderMaximun＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputShadowAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputShadowBlurRadius＝{

　　  class＝NSNumber；
				
				<dp n="d116"/>
　　  default＝10；

　　  identity＝10；

　　  minimum＝0；

　　  sliderMaximum＝100；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputSbadowColor＝{class＝ClColor；default＝＜0，0，0，1＞；type＝
color；}；

　　inputShadowOffset＝{

　　  class＝NSNumber；

　　  default＝0；

　　  minimum＝0；

　　  sliderMaximum＝80；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputShadowOpacity＝{

　　  class＝NSNumber；

　　  default＝0.72；

　　  minimum＝0；

　　  sliderMaximum＝3；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　name＝″Layer With Drop Shadow″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 89；CIVideoNoiseFilter-------------
{

　　category＝Stylize；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputExtent＝{class＝CIVector；default＝＜0，0，640，80＞；type＝
rectangle；}；

　　inputImage＝{class＝CIImage；}；

　　inputOpacity＝{

　　  class＝NSNumber；

　　  default＝1；

　　  minimum＝0；

　　  sliderMaximum＝2；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputScale＝{
				
				<dp n="d117"/>
　　  class＝NSNumber；

　　  default＝1；

　　  minimum＝1；

　　  sliderMaximum＝100；

　　  sliderMinimum＝1；

　　  type＝scalar；

　　}；

　　inputTexture＝{class＝CIImage；}；

　　name＝″Video Noise″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 90：CISpotLight-------------
{

　　category＝Stylize；

　　inputBrightness＝{

　　  class＝NSNumber；

　　  default＝3；

　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝10；

　　  sliderMinimum＝0；

　　  typc＝distance；

　　}；

　　inputColor＝{class＝CIColor；default＝＜1，1，1，1＞；type＝
opaqueColor；}；

　　inputConcentration＝{

　　  class＝NSNumber；

　　  default＝0.1；

　　  identity＝20；

　　  minimum＝0.001；

　　  sliderMaximum＝1.5；

　　  sliderMinimum＝0.001；

　　  type＝scalar；

　　}；

　　inputElevation＝{

　　  class＝NSNumber；

　　  default＝0.3；

　　  identity＝0.3；

　　  minimum＝0；

　　  sliderMaximum＝1.570796326794897；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputLightPointsAt＝{class＝CIVector；default＝＜200，200，0，1＞；
				
				<dp n="d118"/>
type＝position3；}；

　　inputLightPosition＝{class＝CIVector；default＝＜400，600，150，
1＞；type＝position3；}；

　　name＝″Spot Light″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 91；CIBlendWithMask-------------
{

　　category＝Compositing；

　　inputImage＝{class＝CIImage；}；

　　inputImage2＝{class＝CIImage；}；

　　inputMask＝{class＝CIImage；}；

　　inputOpacity＝{

　　  class＝NSNumber；

　　  default＝1；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　name＝″Blend With Mask″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 92；CIRoundedSurface-------------
{

　　category＝Stylize；

　　inputBearing＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝-3.141592653589793；

　　  sliderMaximum＝3.141592653589793；

　　  sliderMinimum＝-3.141592653589793；

　　  type＝angle；

　　}；

　　inputBrightness＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝8；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；
				
				<dp n="d119"/>
　　inputColor＝{class＝CIColor；default＝＜1，1，1，1＞；type＝
opaqueColor；}；

　　inputElevation＝{

　　  class＝NSNumber；

　　  default＝0.1；

　　  identity＝0.1；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　iuputEnvironmentMap＝{class＝CIImage；}；

　　inputImage＝{class＝CIImage；}；

　　inputReflection＝{

　　  class＝NSNumber；

　　  default＝0.2；

　　  identity＝0.2；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputRoundness＝{

　　  class＝NSNumber；

　　  default＝0.4；

　　  identity＝0.4；

　　  minimum＝-1；

　　  sliderMaximum＝2；

　　  sliderMinimum＝-1；

　　  type＝scalar；

　　}；

　　inputSurfaceScale＝{

　　  class＝NSNumber；

　　  default＝-1.6；

　　  identity＝-1.6；

　　  minimum＝-5；

　　  sliderMaximum＝3；

　　  sliderMinimum＝-5；

　　  type＝scalar；

　　}；

　　name＝″Rounded Surface″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 93：CIEmboss-------------
{
				
				<dp n="d120"/>
　　category＝Stylize；

　　inputBearing＝{

　　  class＝NSNumbcr；

　　  default＝0；

　　  identity＝0；

　　  minimum＝-3.141592653589793；

　　  sliderMaximum＝3.141592653589793；

　　  slierMinimum＝-3.141592653589793；

　　  type＝angle；

　　}；

　　inputBrightness＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝8；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputColor＝{class＝CIColor；default＝＜1，1，1，1＞；type＝
opaqueColon；}；

　　inputElevation＝{

　　  class＝NSNumber；

　　  default＝0.1；

　　  identity＝0.1；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputEnvironmentMap＝{class＝CIImage；}；

　　inputImage＝{class＝CIImage；}；

　　inputReflection＝{

　　  class＝NSNumber；

　　  default＝0.2；

　　  identity＝0.2；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputRoundness＝{

　　  class＝NSNumber；

　　  default＝0.4；

　　  identity＝0.4；

　　  minimum＝-1；
				
				<dp n="d121"/>
　    sliderMaximum＝2；

　    sliderMinimum＝-1；

　    type＝scalar；

　  }；

　  inputSurfaceScale＝{

　    class＝NSNumber；

　    default＝-1.6；

　    identity＝-1.6；

　    minimum＝-5；

　    sliderMaximum＝3；

　    sliderMinimum＝-5；

　    type＝scalar；

　  }；

　  name＝Emboss；

　  outputImage＝{class＝CIImage；}；
}
-------------Filter # 94：CIEmbossOver-------------
{

　　category＝Stylize；

　　inputBeaing＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  minimum＝-3.141592653589793；

　　  sliderMaximum＝3.141592653589793；

　　  sliderMinimum＝-3.141592653589793；

　　  type＝angle；

　　}；

　　inputBrightness＝{

　　  class＝NSNumber；

　　  default＝1；

　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝8；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputElevation＝{

　　  class＝NSNumber；

　　  default＝0.1；

　　  identity＝0.1；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝angle；
				
				<dp n="d122"/>
　　}；

　　inputImage＝{class＝CIImage；}；

　　inputRoundness＝{

　　  class＝NSNumber；

　　  default＝0.4；

　　  identity＝0.4；

　　  minimum＝-1；

　　  slidenMaximum＝2；

　　  sliderMinimum＝-1；

　　  type＝scalar；

　　}；

　　inputSurfaceScale＝{

　　  class＝NSNumber；

　　  default＝-1.6；

　　  identity＝-1.6；

　　  minimum＝-5；

　　  sliderMaximum＝3；

　　  sliderMinimum＝-5；

　　  type＝scalar；

　　}；

　　inputTexture＝{class＝CIImage；}；

　　name＝″Emboss Over″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 95：CISpotLight3-------------
{

　　category＝Stylize；

　　inputBrightness1＝{

　　  class＝NSNumber；

　　  default＝3；

　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝10；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputBrightness2＝{

　　  class＝NSNumber；

　　  default＝3；
　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝10；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；
				
				<dp n="d123"/>
　　inputBrightness3＝{

　　  class＝NSNumber；

　　  default＝3；
　　  identity＝1；

　　  minimum＝0；

　　  sliderMaximum＝10；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputColor1＝{class＝CIColor；default＝＜1，1，1，1＞；type＝
opaqueColor；}；

　　inputColor2＝{class＝CIColor；default＝＜1，1，1，1＞；type＝
opaqueColor；}；

　　inputColor3＝{class＝CIColor；default＝＜1，1，1，1＞；type＝
opaqueColor；}；

　　inputConcentration1＝{

　　  class＝NSNumber；

　　  default＝0.1；

　　  identity＝20；

　　  minimum＝0.001；

　　  sliderMaximum＝1.5；

　　  sliderMinimum＝0.001；

　　  type＝scalar；

　　}；

　　inputConcentration2＝{

　　  class＝NSNumber；

　　  default＝0.1；

　　  identity＝20；

　　  minimum＝0.001；

　　  sliderMaximum＝1.5；

　　  sliderMinimum＝0.001；

　　  type＝scalar；

　　}；

　　inputConcentration3＝{

　　  class＝NSNumber；

　　  default＝0.1；

　　  identity＝20；

　　  minimum＝0.001；

　　  sliderMaximum＝1.5；

　　  sliderMininum＝0.001；

　　  type＝scalar；

　　}；

　　inputElevation1＝{

　　  class＝NSNumber；

　　  default＝0.3；

　　  identity＝0.3；
				
				<dp n="d124"/>
　　  minimum＝0；

　　  sliderMaximum＝1.570796326794897；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputElevation2＝{

　　  class＝NSNumber；

　　  default＝0.3；

　　  identity＝0.3；

　　  minimum＝0；

　　  sliderMaximum＝1.570796326794897；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputElevation3＝{

　　  class＝NSNumber；

　  default＝0.3；

　　  identity＝0.3；

　　  minimum＝0；

　　  sliderMaximum＝1.570796326794897；

　　  sliderMmimum＝0；

　　  type＝scalar；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputLightPointsAt1＝{class＝CIVector；default＝＜200，200，0，
1＞；type＝position3；}；

　　inputLightPointsAt2＝{class＝CIVector；default＝＜200，200，0，
1＞；type＝position3；}；

　　inputLightPointsAt3＝{class＝CIVector；default＝＜200，200，0，
1＞；type＝position3；}；

　　inputLightPosition1＝{class＝CIVector；default＝＜400，600，150，
1＞；type＝position3；}；

　　inputLightPosition2＝{class＝CIVector；default＝＜400，600，150，
1＞；type＝position3；}；

　　inputLightPosition3＝{class＝CIVector；default＝＜400，600，150，
1>；type＝position3；}；

　　name＝″Spot Light 3″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 96：CIGaussianBlur-------------
{

　　category＝Focus；

　　inputImage＝{class＝CIImage；}；

　　inputRadius＝{

　　  class＝NSNumber；
				
				<dp n="d125"/>
　　  default＝10；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝100；

　　  sliderMinimum＝0；

　　  type＝distance；
　　}；

　　name＝″Gaussian Blur″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 97：CIMotionBlur-------------
{

　　category＝Focus；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0；

　　  identity＝0；

　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputImage＝{class＝CIImage；}；
　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝20；

　　  idcntity＝0；

　　  minimum＝0；

　　  sliderMaximum＝100；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　name＝″Motion Blur；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 98：CIAxialBlur-------------
{

　　category＝Focus；

　　inputImage＝{class＝CIImage；}；

　　inputPoint1＝{class＝CIVector；default＝＜0，0，0，1＞；type＝
position；}；
　　inputPoint2＝{class＝CIVector；default＝＜200，200，0，1＞；type＝
position；}；
				
				<dp n="d126"/>
    inputRadius＝{

      class＝NSNumber；

      default＝10；

      identity＝0；

      minimum＝0；

      sliderMaximum＝100；

      sliderMinimum＝0；

      type＝distance；

    }；

    name＝″Axial Blur″；

    outputImage＝{class＝CIImage；}；
}    
--------------Filter#99：CIVariableBlur---------------
{

    category＝Focus；

    inputAmount＝{

      class＝NSNumber；

      default＝10；
 
      identity＝0；
      minimum＝0;

      sliderMaximum＝100；

      sliderMinimum＝0；

      type＝distance；

    }；

    inputCenter＝{class＝CIVector；default＝<150，150，0，1>；type＝
position；}；

    inputImage＝{class＝CIImage；}；

    inputInnerRadius＝{

      class＝NSNumber；
      default＝400；
      identity＝400；

      minimum＝0；

      sliderMaximum＝1000；

      sliderMinimum＝0；

      type＝distance；

    }；

    inputOuterRadius＝{

      class＝NSNumber；

      default＝100；

      identity＝100；

      minimum＝0；

      sliderMaximum＝1000；

      sliderMinimum＝0；

      type＝distance；

    }；
				
				<dp n="d127"/>
　　name＝″Variable Blur″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 100：CICentralBlur-------------
{

　　category＝Focus；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputEffectRadius＝{

　　  class＝NSNurmber；

　　  default＝400；

　　  identity＝400；

　　  minimum＝0：

　　  sliderMaximum＝1000；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputRadius＝{

　　  class＝NSNumber；

　　  default＝10；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝100；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　name＝″Central Blur″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 101：CIRadialBlur-------------
{

　　category＝Focus；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0.5235987755982988；

　　  identity＝0；

　　  maximum＝6.283185307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
				
				<dp n="d128"/>
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputSubsampling＝{

  　　class＝NSNumber；

　　  default＝0.0036；

　　  identity＝0.0036；

　　  minimum＝0.001；

　　  sliderMaximum＝0.02；

　　  sliderMinimum＝0.001；

　　  type＝anglc；

　　}；

　　namc＝″Radial Blur″；

  　outputImage＝{class＝CIImage；}；
}
-------------Filtcr # 102：CIZoomBlur-------------
{

　　category＝Focus；

　　inputAmount＝{

　　  class＝NSNumber；

　　  default＝20；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝200；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputImage＝{class＝CIImage；}；

　　inputSampling＝{

　　  class＝NSNumber；

　　  default＝0.994；

　　  identity＝0.994；

　　  minimum＝0.98；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0.98；

　　  type＝scalar；

　　}；

　　name＝″Zoom Blur″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 103：CIAxialMotionBlur-------------
{

　　category＝Focus；
				
				<dp n="d129"/>
　　inputAmount＝{
　　  class＝NSNumber；

　　  default＝10；

　　  identity＝0；

　　  minimum＝0；

　　  sliderMaximum＝200；

　　  sliderMinimum＝0；

　　  type＝distance；

　　}；

　　inputAngle＝{

　　  class＝NSNumber；

　　  default＝0；
　　  identity＝0；

　　  maximum＝6.28385307179586；

　　  minimum＝0；

　　  sliderMaximum＝6.283185307179586；

　　  sliderMinimum＝0；

　　  type＝angle；

　　}；

　　inputImage＝{class＝CIImage；}；

　　inputPoint1＝{class＝CIVector；default＝＜0，0，0，1＞；type＝
position；}；

　　inputPoint2＝{class＝CIVector；default＝＜200，200，0，1＞；type＝
position；}；

　　name＝″Axial Motion Blur″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 104：CIFractalNoiseGenerator-------------{

　　category＝Generator；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputScale＝{

　　  class＝NSNumber；

　　  default＝0.5；

　　  minimum＝0；

　　  sliderMaximum＝1；
　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputSmoothness＝{

　　  class＝NSNumber；

　　  default＝0.7；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；
				
				<dp n="d130"/>
　　  type＝scalar；

　　}；

　　inputTexture＝{class＝CIImage；}；

　　name＝″Fractal Noise″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 105：CIBlockyFractalNoiseGenerator-------------{

　　category＝Generator；

　　inputCenter＝{class＝CIVector；default＝＜150，150，0，1＞；type＝
position；}；

　　inputScale＝{

　　  class＝NSNumber；

　　  default＝0.5；

　　  minimum＝0；

　  　sliderMaximum＝1；　

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputSmoothness＝{

　　  class＝NSNumber；

　　  default＝0.7；

　　  minimum＝0；

　　  sliderMaximum＝1；

　　  sliderMinimum＝0；

　　  type＝scalar；

　　}；

　　inputTexture＝{class＝CIImage；}；

　　name＝″Blocky Fractal Noise″；

　　outputImage＝{class＝CIImage；}；
}
-------------Filter # 106：CISourceOver-------------
{

    category＝Compositing；

    inputImage＝{class＝CIImage；}；

    inputLayer＝{class＝CIImage；}；

    name＝″Source Over″；

    outputImage＝{class＝CIImage；}；
}
-------------Filter # 107；CISourceIn-------------
{

    category＝Compositing；

    inputImage＝{class＝CIImage；}；

    inputLayer＝{class＝CIImage；}；
				
				<dp n="d131"/>
    name＝″Source In″；

    outputImage＝{class＝CIImage；}；
}
------------Filter # 108：CISourceOut-------------
{

    category＝Compositing；

    inputImage＝{class＝CIImage；}；

    inputLayer＝{class＝CIImage；}；

    name＝″Source Out″；

    outputImage＝{class＝CIImage；}；
}
-------------Filter # 109：CISourceAtop-------------
{

    category＝Compositing；

    inputImage＝{class＝CIImage；}；

    inputLayer＝{class＝CIImagc；}；

    name＝″Source Atop；

    outputImage＝{class＝CIImage；}；
}
-------------Filter # 110：CISourceXor-------------
{

    category＝Compositing；

    inputImage＝{class＝CIImage；}；

    inputLayer＝{class＝CIImage；}；

    name＝″Source Xor″；

    outputImage＝{class＝CIImage；}；
}
-------------Filter # 111：CILuminanceToAlpha-------------
{

    category＝Compositing；

    inputImage＝{class＝CIImage；}；

    name＝″Luminance To Alpha″；

    outputImage＝{class＝CIImage；}；
}
如下美国申请由此通过参考包括：Mark Zimmer的标题为“改进模糊计算计算算法”并且提交于2004年4月16日的申请No.10/826,596；John Harper的标题为“用于仿真图形操作的系统”并且提交于2004年4月16日的申请No.10/826,744；John Harper、MarkZimmer、Ralph Brunner、Peter Graffagnino的标题为“用来优化图形操作的系统”并且提交于2004年4月16日的申请No.10/825,694；及John Harper的标题为“用来减小呈现图像必需的程序的数量的系统”并且提交于2004年4月16日的申请No.10/826,773。

Claims (45)

1.一种用图形处理单元和存储器处理关于数据的操作的方法，该方法包括步骤：
a)创建用来累积对于所述数据的变化的数据的累积缓冲器；
b)用所述图形处理单元读取所述累积缓冲器的所述数据的一部分；
c)通过使用所述图形处理单元的操作，来操作所述数据而创建结果；及
d)把所述结果写到在累积缓冲器中的所述数据的所述部分上。
2.根据权利要求1所述的方法，还包括：
在步骤(b)中读取所述数据的所述部分之前，从所述累积缓冲器的所述数据部分创建一个分离的缓冲器，从而该方法包括：
b)用所述图形处理单元从所述分离的缓冲器读取所述数据；
c)通过使用所述图形处理单元的操作，来操作从所述分离的缓冲器读取的所述数据而创建结果；及
d)把所述结果写到与所述分离的缓冲器相对应的累积缓冲器的所述数据部分上。
3.根据权利要求2所述的方法，其中，从累积缓冲器的所述数据的至少一部分创建分离的缓冲器，包括从累积缓冲器读取一个效果区域的步骤，所述效果区域基本上与由所述操作影响的所述数据相对应。
4.根据权利要求2所述的方法，还包括保证在创建分离的缓冲器之前累积缓冲器不被另一个过程读取/修改/或写入的步骤。
5.根据权利要求1所述的方法，其中，累积缓冲器包括用于所述数据的多种数据结构，所述数据结构代表图像的颜色值、向量值、或标量值。
6.根据权利要求1所述的方法，其中，累积缓冲器包括图像的一层、图像的至少一部分、或图像的向量场。
7.根据权利要求1所述的方法，其中，累积缓冲器包括用于所述数据的多种数据结构，所述数据结构具有用于所述数据的多个16位整数、16位浮点、或32位浮点分量。
8.根据权利要求1所述的方法，其中，在累积缓冲器中的所述数据包括图像的象素。
9.根据权利要求1所述的方法，其中，所述创建用来累积对于数据的变化的数据的累积缓冲器，包括从初始图像读取所述数据和把读取数据存储在存储器中。
10.根据权利要求1所述的方法，其中，所述操作包括施加到累积缓冲器上的项目，所述项目包括画笔划、涂画、光源、弯曲、光线轨迹、或局部模糊。
11.根据权利要求10所述的方法，其中，所述操作包括与所述项目如何施加到累积缓冲器上相对应的施加技术，所述施加技术包括光场的添加、向量位移场的添加、或画笔颜色的重叠。
12.根据权利要求1所述的方法，还包括把累积缓冲器施加到一初始图像上的步骤。
13.一种用图形处理单元和存储器处理关于数据的操作的方法，该方法包括步骤：
创建用来累积对于所述数据的变化的数据的累积缓冲器；
从累积缓冲器的所述数据的至少一部分创建一个分离的缓冲器；及
使用在图形处理单元上的一个或多个程序，通过借助于所述程序从分离的缓冲器读取所述数据和借助于所述程序把操作结果写到累积缓冲器，而操作所述分离的缓冲器上的所述数据。
14.根据权利要求13所述的方法，其中，累积缓冲器包括用于所述数据的多种数据结构，所述数据结构代表图像的颜色值、向量值、或标量值。
15.根据权利要求13所述的方法，其中，累积缓冲器包括图像的一层、图像的至少一部分、或图像的向量场。
16.根据权利要求13所述的方法，其中，累积缓冲器包括用于所述数据的多种数据结构，所述数据结构具有用于所述数据的多个16位整数、16位浮点、或32位浮点分量。
17.根据权利要求13所述的方法，其中，在累积缓冲器中的所述数据包括图像的象素。
18.根据权利要求13所述的方法，其中，所述创建用来累积对于所述数据的变化的数据的累积缓冲器，包括从初始图像读取所述数据和把读取数据存储在存储器中。
19.根据权利要求13所述的方法，其中，从累积缓冲器的所述数据的至少一部分创建分离的缓冲器，包括从累积缓冲器读取一个效果区域的步骤，所述效果区域基本与由所述操作影响的所述数据相对应。
20.根据权利要求13所述的方法，其中，所述操作包括施加到累积缓冲器上的项目，所述项目包括画笔划、涂画、光源、弯曲、光线轨迹、或局部模糊。
21.根据权利要求20所述的方法，其中，所述操作包括与所述项目如何施加到累积缓冲器上相对应的施加技术，所述施加技术包括光场的添加、向量位移场的添加、或画笔颜色的重叠。
22.根据权利要求13所述的方法，还包括把累积缓冲器施加到初始图像上的步骤。
23.根据权利要求13所述的方法，还包括保证在创建分离的缓冲器之前累积缓冲器不被另一个过程读取/修改/或写入的步骤。
24.根据权利要求13所述的方法，其中，所述程序包括在滤波器与初始图像之间的关系，由第一过程定义所述关系，从第二过程由所述第一过程请求所述滤波器，所述第二过程编译所述程序并且产生一个编译程序，所述编译程序的至少一部分把所述滤波器的功能施加到所述图像上，以产生作为结果的象素-图像。
25.根据权利要求24所述的方法，其中，所述程序包括高速缓冲存储器查阅表，用于确定所述象素-图像的结果是否已经在存储器的高速缓冲存储器中。
26.根据权利要求24所述的方法，其中，所述程序计算一个交集，其代表这样一个区域，该区域处所述象素-图像结果既被定义并且在所述第二过程请求的结果区域中。
27.根据权利要求26所述的方法，其中，所计算的交集限制在编译程序的运行期间要求计算的象素数量。
28.根据权利要求26所述的方法，其中，所计算的交集限制用来存储计算图像所必需的存储器量。
29.一种用图形处理单元和存储器处理关于初始图像的图形操作的方法，该方法包括步骤：
用所述初始图像的数据创建累积缓冲器，用来累积对于所述数据的变化；
通过重叠多个单独效果计算所述图形操作；
其中，对于每个单独效果，该方法包括步骤：
仅把被每个单独效果影响的累积缓冲器中的数据存储到一个分离的缓冲器中，
使用在分离的缓冲器中的所述数据计算所述每个单独效果的结果，及
把所述结果写入累积缓冲器中的被所述每个单独效果影响的累积缓冲器中的对应数据处。
30.根据权利要求29所述的方法，其中，累积缓冲器包括用于所述数据的多种数据结构，所述数据结构具有大于8比特每分量的多个分量用于所述数据。
31.根据权利要求30所述的方法，其中，累积缓冲器包括用于所述数据的多个16位整数、16位浮点、或32位浮点分量。
32.根据权利要求29所述的方法，其中，累积缓冲器包括用于所述数据的多种数据结构，所述数据结构代表图像的颜色值、向量值、或标量值。
33.根据权利要求29所述的方法，其中，累积缓冲器包括所述初始图像的层、初始图像的至少一部分、或初始图像的向量场。
34.根据权利要求29所述的方法，其中，在累积缓冲器中的所述数据包括所述初始图像的象素。
35.根据权利要求29所述的方法，其中，所述创建用来累积对于所述数据的变化的数据的累积缓冲器，包括从初始图像读取所述数据和把读取数据存储在存储器中。
36.根据权利要求29所述的方法，其中，从累积缓冲器的所述数据的至少一部分创建分离的缓冲器，包括从累积缓冲器读取一个效果区域的步骤，所述效果区域基本与由所述图形操作影响的所述数据相对应。
37.根据权利要求29所述的方法，其中，所述图形操作包括画笔划、涂画、光源、弯曲、光线轨迹、或局部模糊。
38.根据权利要求29所述的方法，其中，所述单独效果包括光场的添加、向量位移场的添加、或画笔颜色的重叠。
39.根据权利要求29所述的方法，还包括把累积缓冲器施加到初始图像上的步骤。
40.根据权利要求29所述的方法，还包括保证在创建分离的缓冲器之前累积缓冲器不被另一个过程读取/修改/或写入的步骤。
41.一种计算机可读介质，具有用来完成根据权利要求1、13、或29的任一项所述的方法的计算机可执行指令。
42.一种用来处理关于多种数据的操作的系统，该系统包括：
图形处理单元，用来处理数据；
存储器，用来存储所述数据；
用来在存储器中创建所述数据的累积缓冲器的装置，以累积对于所述数据的变化；
用来从累积缓冲器的所述数据的至少一部分创建在存储器中的分离的缓冲器的装置；
用来借助于图形处理单元从所述分离的缓冲器读取所述数据的装置；
用来通过使用图形处理单元的操作，来操作从分离的缓冲器读取的所述数据以创建结果的装置；及
用来把所述结果写到与所述分离的缓冲器相对应的累积缓冲器的所述部分上的装置。
43.根据权利要求42所述的系统，其中，累积缓冲器包括用于所述数据的多种数据结构，所述数据结构代表图像的颜色值、向量值、或标量值。
44.根据权利要求42所述的系统，其中，累积缓冲器包括图像的层、图像的至少一部分、或图像的向量场。
45.根据权利要求42所述的系统，其中，累积缓冲器包括用于所述数据的多种数据结构，所述数据结构具有用于数据的多个16位整数、16位浮点、或32位浮点分量。
CN2005800114618A 2004-04-16 2005-03-16 用图形处理单元处理图形操作的系统和方法 Expired - Fee Related CN1942896B (zh)

Applications Claiming Priority (5)

Application Number Priority Date Filing Date Title
US10/826,762 US8704837B2 (en) 2004-04-16 2004-04-16 High-level program interface for graphics operations
US10/826,762 2004-04-16
US10/866,360 US7248265B2 (en) 2004-04-16 2004-06-11 System and method for processing graphics operations with graphics processing unit
US10/866,360 2004-06-11
PCT/US2005/008805 WO2005106785A1 (en) 2004-04-16 2005-03-16 System and method for processing graphics operations with graphics processing unit

Publications (2)

Publication Number Publication Date
CN1942896A true CN1942896A (zh) 2007-04-04
CN1942896B CN1942896B (zh) 2010-05-26

Family

ID=34962678

Family Applications (1)

Application Number Title Priority Date Filing Date
CN2005800114618A Expired - Fee Related CN1942896B (zh) 2004-04-16 2005-03-16 用图形处理单元处理图形操作的系统和方法

Country Status (5)

Country Link
US (2) US8704837B2 (zh)
EP (6) EP1775680B1 (zh)
JP (4) JP2007533026A (zh)
CN (1) CN1942896B (zh)
WO (1) WO2005106652A1 (zh)

Cited By (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN102221984A (zh) * 2010-06-14 2011-10-19 微软公司 独立地处理显示数据的平面
CN104966265A (zh) * 2014-03-19 2015-10-07 Arm有限公司 图形处理系统
CN108074272A (zh) * 2017-12-21 2018-05-25 珠海亿智电子科技有限公司 一种仿真图形混合处理的方法
CN110133625A (zh) * 2019-05-20 2019-08-16 北京奥特贝睿科技有限公司 一种快速球坐标激光雷达仿真方法
CN113127945A (zh) * 2021-05-18 2021-07-16 福建天晴在线互动科技有限公司 一种基于Compute Shader的实时布料仿真的方法及其系统

Families Citing this family (30)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7636489B2 (en) * 2004-04-16 2009-12-22 Apple Inc. Blur computation algorithm
US7554550B2 (en) * 2005-06-24 2009-06-30 Microsoft Corporation Non-destructive processing of digital image data
US7295208B2 (en) * 2005-06-24 2007-11-13 Microsoft Corporation Translating layers into effect graphs in digital image processing
US20060290705A1 (en) * 2005-06-24 2006-12-28 Microsoft Corporation Performing a pre-rendering pass in digital image processing
US7519233B2 (en) * 2005-06-24 2009-04-14 Microsoft Corporation Accumulating transforms through an effect graph in digital image processing
US7619628B2 (en) * 2005-06-24 2009-11-17 Microsoft Corporation Caching digital image data
US8860752B2 (en) * 2006-07-13 2014-10-14 Apple Inc. Multimedia scripting
US8615747B2 (en) * 2007-04-18 2013-12-24 Apple Inc. Method and apparatus for dynamic code optimization
US8884981B2 (en) * 2007-09-04 2014-11-11 Apple Inc. Dynamically reconfigurable graphics layer system and method
US8610725B2 (en) * 2007-10-10 2013-12-17 Apple Inc. Framework for dynamic configuration of hardware resources
US8347310B1 (en) * 2007-11-12 2013-01-01 Nvidia Corporation System and method for representing and managing a multi-architecure co-processor application program
US8229211B2 (en) * 2008-07-29 2012-07-24 Apple Inc. Differential image enhancement
US9778921B2 (en) 2009-06-02 2017-10-03 Apple Inc. Method for creating, exporting, sharing, and installing graphics functional blocks
US8584027B2 (en) * 2009-06-02 2013-11-12 Apple Inc. Framework for designing physics-based graphical user interface
CN101706961B (zh) * 2009-11-10 2012-12-12 北京航空航天大学 一种图像的配准方法及装置
US8301716B2 (en) * 2009-11-20 2012-10-30 Time Warner Cable Inc. Interface for a multi-processor gateway apparatus and method for using the same
US9727385B2 (en) * 2011-07-18 2017-08-08 Apple Inc. Graphical processing unit (GPU) implementing a plurality of virtual GPUs
US9682315B1 (en) * 2011-09-07 2017-06-20 Zynga Inc. Social surfacing and messaging interactions
JP2013073543A (ja) * 2011-09-29 2013-04-22 Fixstars Corp 画像処理フィルタ統合装置、画像処理フィルタ統合方法、およびプログラム
CN102810200A (zh) * 2012-06-15 2012-12-05 成都平行视野科技有限公司 一种图像批处理的方法
FR2996037B1 (fr) * 2012-09-24 2015-05-29 Allegorithmic Moteur hybride pour processeur central et processeur graphique
US10445319B2 (en) 2017-05-10 2019-10-15 Oracle International Corporation Defining subgraphs declaratively with vertex and edge filters
US10445218B2 (en) 2017-06-06 2019-10-15 Microsoft Technology Licensing, Llc Execution of graphic workloads on a simulated hardware environment
CN107945099B (zh) * 2017-11-24 2021-06-01 中国航空工业集团公司西安航空计算技术研究所 一种面向OpenGL实现的属性配置优化方法
CN111768464B (zh) * 2019-04-01 2023-09-19 珠海金山办公软件有限公司 一种图形调整方法及装置
CN112233202B (zh) * 2019-07-15 2023-09-19 珠海金山办公软件有限公司 一种正多边形绘制方法、装置、电子设备及可读存储介质
US11263060B2 (en) 2019-11-21 2022-03-01 International Business Machines Corporation Dynamic distribution of loads across heterogeneous computing structures in computational rendering
CN111242838B (zh) * 2020-01-09 2022-06-03 腾讯科技（深圳）有限公司 模糊图像渲染方法和装置、存储介质及电子装置
US20210303763A1 (en) * 2020-03-26 2021-09-30 Mappedin Inc. Systems and methods for geometry simplification and filtering
CN116468597B (zh) * 2023-02-16 2023-11-17 深圳技术大学 基于多gpu的图像渲染方法、装置及可读存储介质

Family Cites Families (155)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4752893A (en) * 1985-11-06 1988-06-21 Texas Instruments Incorporated Graphics data processing apparatus having image operations with transparent color having a selectable number of bits
US5113494A (en) * 1987-02-27 1992-05-12 Eastman Kodak Company High speed raster image processor particularly suited for use in an image management system
US5063375A (en) 1987-07-27 1991-11-05 Sun Microsystems, Inc. Method and apparatus for shading images
GB8823239D0 (en) 1988-10-04 1988-11-09 Gems Of Cambridge Ltd Improved data processing
US5262965A (en) 1988-10-31 1993-11-16 Bts-Broadcast Television Systems, Inc. System and method for high speed computer graphics image computation using a parallel connected, asynchronous multiprocessor ring coupled to a synchronous special purpose video processing ring
US5140444A (en) * 1989-10-10 1992-08-18 Unisys Corporation Image data processor
US5410649A (en) * 1989-11-17 1995-04-25 Texas Instruments Incorporated Imaging computer system and network
US5168441A (en) 1990-05-30 1992-12-01 Allen-Bradley Company, Inc. Methods for set up and programming of machine and process controllers
US5388201A (en) 1990-09-14 1995-02-07 Hourvitz; Leonard Method and apparatus for providing multiple bit depth windows
EP0528631B1 (en) * 1991-08-13 1998-05-20 Xerox Corporation Electronic image generation
US5274760A (en) 1991-12-24 1993-12-28 International Business Machines Corporation Extendable multiple image-buffer for graphics systems
DE69315969T2 (de) * 1992-12-15 1998-07-30 Sun Microsystems Inc Darstellung von Informationen in einem Anzeigesystem mit transparenten Fenstern
JPH06282602A (ja) 1993-03-29 1994-10-07 Hitachi Ltd 多段論理生成方法
US5475840A (en) 1993-04-13 1995-12-12 Sun Microsystems, Inc. High performance dynamic linking through caching
US5522022A (en) * 1993-11-24 1996-05-28 Xerox Corporation Analyzing an image showing a node-link structure
US6396504B1 (en) * 1994-04-29 2002-05-28 Sun Microsystems, Inc. Graphical image data reformatting method and apparatus
US6757438B2 (en) * 2000-02-28 2004-06-29 Next Software, Inc. Method and apparatus for video compression using microwavelets
US6031937A (en) 1994-05-19 2000-02-29 Next Software, Inc. Method and apparatus for video compression using block and wavelet techniques
US5706478A (en) * 1994-05-23 1998-01-06 Cirrus Logic, Inc. Display list processor for operating in processor and coprocessor modes
AUPM704294A0 (en) * 1994-07-25 1994-08-18 Canon Information Systems Research Australia Pty Ltd Method and apparatus for the creation of images
AUPM704194A0 (en) 1994-07-25 1994-08-18 Canon Information Systems Research Australia Pty Ltd Efficient methods for the evaluation of a graphical programming language
JP2951572B2 (ja) * 1994-09-12 1999-09-20 インターナショナル・ビジネス・マシーンズ・コーポレイション 画像データ変換方法及びシステム
JP3578498B2 (ja) 1994-12-02 2004-10-20 株式会社ソニー・コンピュータエンタテインメント 画像情報処理装置
JP3647487B2 (ja) 1994-12-02 2005-05-11 株式会社ソニー・コンピュータエンタテインメント テクスチャマッピング装置
US5949409A (en) 1994-12-02 1999-09-07 Sony Corporation Image processing in which the image is divided into image areas with specific color lookup tables for enhanced color resolution
AU4471496A (en) 1994-12-22 1996-07-10 Apple Computer, Inc. Three-dimensional graphics rendering system
US5877762A (en) * 1995-02-27 1999-03-02 Apple Computer, Inc. System and method for capturing images of screens which display multiple windows
US5742796A (en) * 1995-03-24 1998-04-21 3Dlabs Inc. Ltd. Graphics system with color space double buffering
US5877741A (en) * 1995-06-07 1999-03-02 Seiko Epson Corporation System and method for implementing an overlay pathway
EP0789882B1 (en) 1995-07-21 2000-10-04 Koninklijke Philips Electronics N.V. Multi-media processor architecture with high performance-density
US5793374A (en) * 1995-07-28 1998-08-11 Microsoft Corporation Specialized shaders for shading objects in computer generated images
US5990904A (en) 1995-08-04 1999-11-23 Microsoft Corporation Method and system for merging pixel fragments in a graphics rendering system
US5854637A (en) * 1995-08-17 1998-12-29 Intel Corporation Method and apparatus for managing access to a computer system memory shared by a graphics controller and a memory controller
US6331856B1 (en) 1995-11-22 2001-12-18 Nintendo Co., Ltd. Video game system with coprocessor providing high speed efficient 3D graphics and digital audio signal processing
US5872729A (en) 1995-11-27 1999-02-16 Sun Microsystems, Inc. Accumulation buffer method and apparatus for graphical image processing
WO1997032248A1 (fr) 1996-02-29 1997-09-04 Sony Computer Entertainment, Inc. Processeur d'images et procede de traitement d'images
US6044408A (en) * 1996-04-25 2000-03-28 Microsoft Corporation Multimedia device interface for retrieving and exploiting software and hardware capabilities
US5764229A (en) * 1996-05-09 1998-06-09 International Business Machines Corporation Method of and system for updating dynamic translucent windows with buffers
JP3537259B2 (ja) 1996-05-10 2004-06-14 株式会社ソニー・コンピュータエンタテインメント データ処理装置およびデータ処理方法
AUPO002196A0 (en) * 1996-05-22 1996-06-13 Canon Information Systems Research Australia Pty Ltd A method of optimising an expression tree for the production of images
US5896139A (en) * 1996-08-01 1999-04-20 Platinum Technology Ip, Inc. System and method for optimizing a scene graph for optimizing rendering performance
US6078688A (en) * 1996-08-23 2000-06-20 Nec Research Institute, Inc. Method for image segmentation by minimizing the ratio between the exterior boundary cost and the cost of the enclosed region
US6006231A (en) 1996-09-10 1999-12-21 Warp 10 Technologies Inc. File format for an image including multiple versions of an image, and related system and method
US5933155A (en) 1996-11-06 1999-08-03 Silicon Graphics, Inc. System and method for buffering multiple frames while controlling latency
US5913038A (en) * 1996-12-13 1999-06-15 Microsoft Corporation System and method for processing multimedia data streams using filter graphs
US6195664B1 (en) * 1997-02-21 2001-02-27 Micrografx, Inc. Method and system for controlling the conversion of a file from an input format to an output format
DE19709305A1 (de) * 1997-03-07 1998-09-17 Fraunhofer Ges Forschung Vorrichtung zur Ausgabe von auf einem Datenträger digital gespeicherten Daten
EP0972273B1 (en) 1997-04-04 2004-03-24 Intergraph Hardware Technologies Company Apparatus and method for applying effects to graphical images
US6215495B1 (en) * 1997-05-30 2001-04-10 Silicon Graphics, Inc. Platform independent application program interface for interactive 3D scene management
US6496190B1 (en) 1997-07-02 2002-12-17 Mental Images Gmbh & Co Kg. System and method for generating and using systems of cooperating and encapsulated shaders and shader DAGs for use in a computer graphics system
US6026478A (en) * 1997-08-01 2000-02-15 Micron Technology, Inc. Split embedded DRAM processor
US5987256A (en) * 1997-09-03 1999-11-16 Enreach Technology, Inc. System and process for object rendering on thin client platforms
US6272558B1 (en) * 1997-10-06 2001-08-07 Canon Kabushiki Kaisha Application programming interface for manipulating flashpix files
US6266053B1 (en) * 1998-04-03 2001-07-24 Synapix, Inc. Time inheritance scene graph for representation of media content
US6480205B1 (en) 1998-07-22 2002-11-12 Nvidia Corporation Method and apparatus for occlusion culling in graphics systems
US6577317B1 (en) 1998-08-20 2003-06-10 Apple Computer, Inc. Apparatus and method for geometry operations in a 3D-graphics pipeline
US6771264B1 (en) 1998-08-20 2004-08-03 Apple Computer, Inc. Method and apparatus for performing tangent space lighting and bump mapping in a deferred shading graphics processor
US8332478B2 (en) * 1998-10-01 2012-12-11 Digimarc Corporation Context sensitive connected content
JP3566889B2 (ja) 1998-10-08 2004-09-15 株式会社ソニー・コンピュータエンタテインメント 情報追加方法、ビデオゲーム機及び記録媒体
US6300953B1 (en) * 1998-10-15 2001-10-09 Nvidia Apparatus and method for grouping texture cache requests
US6115054A (en) * 1998-12-29 2000-09-05 Connectix Corporation Graphics processor emulation system and method with adaptive frame skipping to maintain synchronization between emulation time and real time
US6477683B1 (en) * 1999-02-05 2002-11-05 Tensilica, Inc. Automated processor generation system for designing a configurable processor and method for the same
JP3428922B2 (ja) 1999-02-26 2003-07-22 キヤノン株式会社 画像表示制御方法及び装置
US6753878B1 (en) 1999-03-08 2004-06-22 Hewlett-Packard Development Company, L.P. Parallel pipelined merge engines
US6362822B1 (en) 1999-03-12 2002-03-26 Terminal Reality, Inc. Lighting and shadowing methods and arrangements for use in computer graphic simulations
US6919895B1 (en) * 1999-03-22 2005-07-19 Nvidia Corporation Texture caching arrangement for a computer graphics accelerator
US6421060B1 (en) 1999-03-31 2002-07-16 International Business Machines Corporation Memory efficient system and method for creating anti-aliased images
US6369830B1 (en) * 1999-05-10 2002-04-09 Apple Computer, Inc. Rendering translucent layers in a display system
US6434742B1 (en) * 1999-05-10 2002-08-13 Lucent Technologies Inc. Symbol for automatically renaming symbols in files during the compiling of the files
US6321314B1 (en) 1999-06-09 2001-11-20 Ati International S.R.L. Method and apparatus for restricting memory access
US6542160B1 (en) * 1999-06-18 2003-04-01 Phoenix Technologies Ltd. Re-generating a displayed image
US6433788B1 (en) * 1999-07-30 2002-08-13 Ati International Srl Dual fragment-cache pixel processing circuit and method therefore
US6260370B1 (en) * 1999-08-27 2001-07-17 Refrigeration Research, Inc. Solar refrigeration and heating system usable with alternative heat sources
US7170511B2 (en) * 1999-09-24 2007-01-30 Sun Microsystems, Inc. Creating a parallel structure for scene-based rendering
US6221890B1 (en) * 1999-10-21 2001-04-24 Sumitomo Chemical Company Limited Acaricidal compositions
US6411301B1 (en) * 1999-10-28 2002-06-25 Nintendo Co., Ltd. Graphics system interface
US6618048B1 (en) 1999-10-28 2003-09-09 Nintendo Co., Ltd. 3D graphics rendering system for performing Z value clamping in near-Z range to maximize scene resolution of visually important Z components
US6452600B1 (en) 1999-10-28 2002-09-17 Nintendo Co., Ltd. Graphics system interface
US6263302B1 (en) * 1999-10-29 2001-07-17 Vast Systems Technology Corporation Hardware and software co-simulation including simulating the cache of a target processor
US6457034B1 (en) 1999-11-02 2002-09-24 Ati International Srl Method and apparatus for accumulation buffering in the video graphics system
US6867779B1 (en) * 1999-12-22 2005-03-15 Intel Corporation Image rendering
US6977661B1 (en) * 2000-02-25 2005-12-20 Microsoft Corporation System and method for applying color management on captured images
US6525725B1 (en) 2000-03-15 2003-02-25 Sun Microsystems, Inc. Morphing decompression in a graphics system
US6955606B2 (en) * 2000-03-30 2005-10-18 Nintendo Co., Ltd. Game information storage medium and game system using the same
US20010029205A1 (en) * 2000-03-30 2001-10-11 Sagahiro Taho Game program delivery system and apparatus used in same
US6857061B1 (en) 2000-04-07 2005-02-15 Nintendo Co., Ltd. Method and apparatus for obtaining a scalar value directly from a vector register
US6707462B1 (en) 2000-05-12 2004-03-16 Microsoft Corporation Method and system for implementing graphics control constructs
US7042467B1 (en) 2000-05-16 2006-05-09 Adobe Systems Incorporated Compositing using multiple backdrops
US7285051B2 (en) * 2000-05-25 2007-10-23 Nintendo Co., Ltd. Game information storage medium and game system using the same
US6910000B1 (en) * 2000-06-02 2005-06-21 Mitsubishi Electric Research Labs, Inc. Generalized belief propagation for probabilistic systems
US6801202B2 (en) * 2000-06-29 2004-10-05 Sun Microsystems, Inc. Graphics system configured to parallel-process graphics data using multiple pipelines
US6717599B1 (en) * 2000-06-29 2004-04-06 Microsoft Corporation Method, system, and computer program product for implementing derivative operators with graphics hardware
US6931633B1 (en) * 2000-08-01 2005-08-16 National Instruments Corporation System and method of evaluating the performance of an image processing algorithm
JP3964142B2 (ja) * 2000-08-15 2007-08-22 株式会社ソニー・コンピュータエンタテインメント エミュレート装置及び部品、情報処理装置、エミュレーション方法、記録媒体、プログラム
US6633297B2 (en) * 2000-08-18 2003-10-14 Hewlett-Packard Development Company, L.P. System and method for producing an antialiased image using a merge buffer
US6580430B1 (en) 2000-08-23 2003-06-17 Nintendo Co., Ltd. Method and apparatus for providing improved fog effects in a graphics system
US7002591B1 (en) * 2000-08-23 2006-02-21 Nintendo Co., Ltd. Method and apparatus for interleaved processing of direct and indirect texture coordinates in a graphics system
US6609977B1 (en) 2000-08-23 2003-08-26 Nintendo Co., Ltd. External interfaces for a 3D graphics system
US6664962B1 (en) 2000-08-23 2003-12-16 Nintendo Co., Ltd. Shadow mapping in a low cost graphics system
US6664958B1 (en) 2000-08-23 2003-12-16 Nintendo Co., Ltd. Z-texturing
US6639595B1 (en) 2000-08-23 2003-10-28 Nintendo Co., Ltd. Achromatic lighting in a graphics system and method
US6636214B1 (en) 2000-08-23 2003-10-21 Nintendo Co., Ltd. Method and apparatus for dynamically reconfiguring the order of hidden surface processing based on rendering mode
KR100373323B1 (ko) * 2000-09-19 2003-02-25 한국전자통신연구원 영상회의 시스템에서의 다자간 영상회의 방법
US6715053B1 (en) 2000-10-30 2004-03-30 Ati International Srl Method and apparatus for controlling memory client access to address ranges in a memory pool
US20020080143A1 (en) * 2000-11-08 2002-06-27 Morgan David L. Rendering non-interactive three-dimensional content
US6882346B1 (en) * 2000-11-17 2005-04-19 Hewlett-Packard Development Company, L.P. System and method for efficiently rendering graphical data
US6697074B2 (en) 2000-11-28 2004-02-24 Nintendo Co., Ltd. Graphics system interface
JP3548521B2 (ja) 2000-12-05 2004-07-28 Ｎｅｃマイクロシステム株式会社 半透明画像処理装置及び方法
US6801208B2 (en) * 2000-12-27 2004-10-05 Intel Corporation System and method for cache sharing
US7098921B2 (en) * 2001-02-09 2006-08-29 Activision Publishing, Inc. Method, system and computer program product for efficiently utilizing limited resources in a graphics device
JP3450833B2 (ja) * 2001-02-23 2003-09-29 キヤノン株式会社 画像処理装置及びその方法並びにプログラムコード、記憶媒体
US6831635B2 (en) 2001-03-01 2004-12-14 Microsoft Corporation Method and system for providing a unified API for both 2D and 3D graphics objects
US7038690B2 (en) * 2001-03-23 2006-05-02 Microsoft Corporation Methods and systems for displaying animated graphics on a computing device
US20020144101A1 (en) * 2001-03-30 2002-10-03 Hong Wang Caching DAG traces
US20020174181A1 (en) 2001-04-13 2002-11-21 Songxiang Wei Sharing OpenGL applications using application based screen sampling
US6828984B2 (en) 2001-04-19 2004-12-07 Sony Corporation System and method for optimizing the processing of images
US6919906B2 (en) * 2001-05-08 2005-07-19 Microsoft Corporation Discontinuity edge overdraw
US6697064B1 (en) * 2001-06-08 2004-02-24 Nvidia Corporation System, method and computer program product for matrix tracking during vertex processing in a graphics pipeline
US7162716B2 (en) * 2001-06-08 2007-01-09 Nvidia Corporation Software emulator for optimizing application-programmable vertex processing
US6995765B2 (en) * 2001-07-13 2006-02-07 Vicarious Visions, Inc. System, method, and computer program product for optimization of a scene graph
US7564460B2 (en) * 2001-07-16 2009-07-21 Microsoft Corporation Systems and methods for providing intermediate targets in a graphics system
US7064766B2 (en) * 2001-10-18 2006-06-20 Microsoft Corporation Intelligent caching data structure for immediate mode graphics
US7234144B2 (en) * 2002-01-04 2007-06-19 Microsoft Corporation Methods and system for managing computational resources of a coprocessor in a computing system
US7600222B2 (en) * 2002-01-04 2009-10-06 Microsoft Corporation Systems and methods for managing drivers in a computing system
JP2003216943A (ja) 2002-01-22 2003-07-31 Toshiba Corp 画像処理装置、この装置に用いられるコンパイラおよび画像処理方法
US7159212B2 (en) * 2002-03-08 2007-01-02 Electronic Arts Inc. Systems and methods for implementing shader-driven compilation of rendering assets
US7145570B2 (en) 2002-03-11 2006-12-05 Sun Microsystems, Inc. Magnified texture-mapped pixel performance in a single-pixel pipeline
US6906720B2 (en) * 2002-03-12 2005-06-14 Sun Microsystems, Inc. Multipurpose memory system for use in a graphics system
US6891543B2 (en) 2002-05-08 2005-05-10 Intel Corporation Method and system for optimally sharing memory between a host processor and graphics processor
US6952206B1 (en) * 2002-08-12 2005-10-04 Nvidia Corporation Graphics application program interface system and method for accelerating graphics processing
GB2392072B (en) 2002-08-14 2005-10-19 Autodesk Canada Inc Generating Image Data
DE10242087A1 (de) 2002-09-11 2004-03-25 Daimlerchrysler Ag Bildverarbeitung auf für Vektorrechnung und Farbmischung optimierter Hardware
GB0226292D0 (en) * 2002-11-12 2002-12-18 Autodesk Canada Inc Generating image data
US7268785B1 (en) * 2002-12-19 2007-09-11 Nvidia Corporation System and method for interfacing graphics program modules
US7928997B2 (en) * 2003-02-06 2011-04-19 Nvidia Corporation Digital image compositing using a programmable graphics processor
US20050140672A1 (en) * 2003-02-18 2005-06-30 Jeremy Hubbell Shader editor and compiler
US6911984B2 (en) * 2003-03-12 2005-06-28 Nvidia Corporation Desktop compositor using copy-on-write semantics
US6911983B2 (en) * 2003-03-12 2005-06-28 Nvidia Corporation Double-buffering of pixel data using copy-on-write semantics
US7530062B2 (en) * 2003-05-23 2009-05-05 Microsoft Corporation Optimizing compiler transforms for a high level shader language
US8214588B2 (en) * 2003-11-05 2012-07-03 International Business Machines Corporation Parallel asynchronous order-preserving transaction processing
US7075541B2 (en) * 2003-08-18 2006-07-11 Nvidia Corporation Adaptive load balancing in a multi-processor graphics processing system
WO2005016926A1 (en) * 2003-08-19 2005-02-24 Warner-Lambert Company Llc Pyrido [3,4-d] pyrimidine derivatives as matrix metalloproteinase-13 inhibitors
US7293264B2 (en) 2003-09-17 2007-11-06 Nokia Corporation Method and a device for abstracting instruction sequences with tail merging
US7817163B2 (en) * 2003-10-23 2010-10-19 Microsoft Corporation Dynamic window anatomy
US7839419B2 (en) * 2003-10-23 2010-11-23 Microsoft Corporation Compositing desktop window manager
US7382378B2 (en) * 2003-10-30 2008-06-03 Sensable Technologies, Inc. Apparatus and methods for stenciling an image
US8077778B2 (en) * 2003-10-31 2011-12-13 Broadcom Corporation Video display and decode utilizing off-chip processor and DRAM
US7180525B1 (en) * 2003-11-25 2007-02-20 Sun Microsystems, Inc. Spatial dithering to overcome limitations in RGB color precision of data interfaces when using OEM graphics cards to do high-quality antialiasing
US7219085B2 (en) * 2003-12-09 2007-05-15 Microsoft Corporation System and method for accelerating and optimizing the processing of machine learning techniques using a graphics processing unit
US7015914B1 (en) * 2003-12-10 2006-03-21 Nvidia Corporation Multiple data buffers for processing graphics data
US7053904B1 (en) * 2003-12-15 2006-05-30 Nvidia Corporation Position conflict detection and avoidance in a programmable graphics processor
US7274370B2 (en) * 2003-12-18 2007-09-25 Apple Inc. Composite graphics rendered using multiple frame buffers
US7463259B1 (en) 2003-12-18 2008-12-09 Nvidia Corporation Subshader mechanism for programming language
US7554538B2 (en) * 2004-04-02 2009-06-30 Nvidia Corporation Video processing, such as for hidden surface reduction or removal
US7248265B2 (en) * 2004-04-16 2007-07-24 Apple Inc. System and method for processing graphics operations with graphics processing unit

Cited By (7)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN102221984A (zh) * 2010-06-14 2011-10-19 微软公司 独立地处理显示数据的平面
CN102221984B (zh) * 2010-06-14 2015-06-17 微软公司 独立地处理显示数据的平面
CN104966265A (zh) * 2014-03-19 2015-10-07 Arm有限公司 图形处理系统
CN108074272A (zh) * 2017-12-21 2018-05-25 珠海亿智电子科技有限公司 一种仿真图形混合处理的方法
CN110133625A (zh) * 2019-05-20 2019-08-16 北京奥特贝睿科技有限公司 一种快速球坐标激光雷达仿真方法
CN113127945A (zh) * 2021-05-18 2021-07-16 福建天晴在线互动科技有限公司 一种基于Compute Shader的实时布料仿真的方法及其系统
CN113127945B (zh) * 2021-05-18 2022-07-19 福建天晴在线互动科技有限公司 一种基于Compute Shader的实时布料仿真的方法及其系统

Also Published As

Publication number Publication date
EP1777618A3 (en) 2007-06-20
JP2007533026A (ja) 2007-11-15
WO2005106652A1 (en) 2005-11-10
JP2010102722A (ja) 2010-05-06
EP1775680A3 (en) 2008-06-04
US8704837B2 (en) 2014-04-22
US20070182747A1 (en) 2007-08-09
JP5043921B2 (ja) 2012-10-10
CN1942896B (zh) 2010-05-26
JP2010102721A (ja) 2010-05-06
EP1777618A2 (en) 2007-04-25
EP1777618B1 (en) 2017-05-03
EP1775681B1 (en) 2017-09-27
JP5043922B2 (ja) 2012-10-10
JP5113143B2 (ja) 2013-01-09
EP1735701A1 (en) 2006-12-27
EP1775681A3 (en) 2007-06-13
EP1735701B1 (en) 2018-12-05
EP1785850A3 (en) 2007-06-13
EP1775680A2 (en) 2007-04-18
US20050231502A1 (en) 2005-10-20
JP2010113724A (ja) 2010-05-20
EP3249522A1 (en) 2017-11-29
EP1775681A2 (en) 2007-04-18
EP1785850A2 (en) 2007-05-16
EP1775680B1 (en) 2019-10-16

Similar Documents

Publication Publication Date Title
CN1942896A (zh) 用图形处理单元处理图形操作的系统和方法
US10402934B2 (en) System for optimizing graphics operations
EP1735748B1 (en) System and method for processing graphics operations with graphics processing unit
US8040353B2 (en) System for emulating graphics operations
US7788656B2 (en) System for reducing the number of programs necessary to render an image
CN100342331C (zh) 用于执行渲染美术品的着色器驱动编译的方法
CN1534476A (zh) 矢量图形的标记语言和对象模型

Legal Events

Date Code Title Description
C06 Publication
PB01 Publication
C10 Entry into substantive examination
SE01 Entry into force of request for substantive examination
C14 Grant of patent or utility model
GR01 Patent grant
CF01 Termination of patent right due to non-payment of annual fee
CF01 Termination of patent right due to non-payment of annual fee

Granted publication date: 20100526