CN103828359B - 用于产生场景的视图的方法、编码系统以及解码系统 - Google Patents

Abstract

描述使用织锦编码的多视图图像的表现和代码化。织锦包括关于织锦图像的信息和与织锦图像关联的世界坐标图，其中的每个可以包含来自场景的一个或更多个视角的信息。场景的视角图像可以根据织锦图像和世界坐标图而产生。

Description

用于产生场景的视图的方法、编码系统以及解码系统

该专利文献的公开内容的一部分包含受到版权保护的材料。当该专利文献或专利公开内容出现在专利商标局专利文档或记录中时，版权所有者不反对任何人传真复制该专利文献或专利公开内容，但除此以外无论如何保留所有版权权利。

相关申请的交叉引用

本申请要求2011年9月29日提交的美国临时专利申请No.61/541,050的优先权，其通过参考全部被并入于此。

技术领域

本公开一般涉及图像和视频处理。更具体地，它涉及使用织锦(tapestry)编码的多视图图像的表现(representation)和代码化(coding)。

背景技术

近来，对于3-D内容的创建和递送已经有相当大的兴趣。已经开发并且正在开发适合于3-D特征的用于TV和媒体格式的编码和解码系统。这种媒体格式的示例性的成像应用可以在立体和自动立体显示以及包含如从多个视点(viewpoint)来观看的场景有关的信息的处理和传输的应用中被找到。通过从视点观看场景而捕获的图像可以被称为视图(view)。

由一个视图遮蔽(occlude)的场景的信息可以由一个或更多个其它视图揭示(reveal)。可以在没有直接捕获的预测视图中利用场景的各个捕获的视图。虽然各个视图可以以整体被提供(例如，用于处理和代码化)以用于成像和视频应用，但是要由代码化系统处理和传输的视图的数量增加通常与3-D内容的创建和递送中涉及的更高计算复杂性以及比特的数量增加关联。因此，3-D内容的创建和递送考虑要提供给代码化系统什么信息(例如，视图的数量以及每个视图内的什么信息)。

发明内容

根据本发明的一个方面，提供一种用于根据织锦图像产生场景的至少一个视图的方法，该至少一个视图中的每一个与场景的一个期望视点关联，所述方法包括如下步骤：

提供织锦图像；其中该织锦图像包括像素的2维阵列，该像素的2维阵列包括来自与场景关联的多个视图的信息；

提供与织锦图像关联的坐标图；其中与织锦图像关联的坐标图包括与织锦图像的像素关联的位置数据；其中与织锦图像的像素关联的位置数据包括用于织锦图像中的每个像素的深度数据；以及其中与织锦图像的像素关联的位置数据还包括用于织锦图像中的每个像素的水平视差数据和/或垂直视差数据；

基于该织锦图像和该坐标图来推导场景的一个或更多个视图。

附图说明

被并入本说明书且构成说明书一部分的附图示出了本公开的一个或更多个实施例，并且与示例实施例的描述一起用来解释本公开的原理和实现方式。

图1示出包含在视频的每一帧中的根据本公开的许多实施例的织锦信息格式。

图2示出包括左视图和右视图的示例性的立体像对(stereopair)。

图3示出根据亮度映射的深度图(depthmap)的深度信息。

图4示出通过结合来自图2中示出的右视图的信息和右视图的图3中示出的深度图导出的左视图。

图5A和5B分别示出导出的最左边的(far-left)视图和与导出的最左边的视图关联的一个可能的校正层。

图6示出与两个视点对应的视图平截头体(frusta)的顶视图的示例。

图7A和7B示出根据第一视点和第二视点获得的场景的视图。图7C示出包括分别来自图7A和7B的第一和第二视图两者的信息的视角(perspective)图像。图7D示出可以根据图7A和7B的第一和第二视图一起产生的一个可能的织锦图像。

图8示出多视角图像，其包括适合于产生与不一定包含在多视角图像中的视点关联的视图的信息。

图9A-9C示出与图8中示出的多视角视图对应的场景坐标。

图10A-10C示出根据图8和9A-9C中示出的织锦制作的三个示例性的呈现。具体地，左、中心和右视图分别被示出在图10A-10C中。

图11提供可以被用于根据图像信息产生3-D网格(mesh)的用于3-D网格呈现的示例性方法。

图12A示出根据来自三个视图的信息的结合产生的织锦图像。图12B-12D一起示出了与图12A的织锦图像关联的3-D世界坐标图。

图13A-13C示出了根据图12A-12D的织锦产生的视图的示例。具体地，图13A-13C分别示出了左视图、中心视图和右视图。

图14示出了用于产生织锦信息和编码视频信息(包括织锦信息在内)的示例性编码系统。

图15示出了被配置为对来自图14的示例性编码系统的信息进行解码的示例性解码系统。

具体实施方式

根据本公开的第一方面，提供了其上存储有与场景关联的织锦信息的计算机可读的存储介质，其中该织锦信息适合于推导场景的一个或更多个期望视图，该织锦信息包括：其上存储有与场景关联的织锦信息的计算机可读的存储介质，其中该织锦信息适合于推导场景的一个或更多个期望视图，该织锦信息包括：织锦图像，其中该织锦图像包括多个像素，该多个像素包括来自与场景关联的多个视图的信息；以及坐标图，包括与织锦图像的像素关联的位置数据。

根据本公开的第二方面，提供了一种用于根据织锦图像产生场景的至少一个视图的方法，该至少一个视图中的每一个与场景的一个期望视点关联，所述方法包括：提供织锦图像；提供与该织锦图像关联的坐标图；基于该织锦图像和该坐标图来推导场景的一个或更多个视图，以及基于该一个或更多个推导出的视图来产生场景的至少一个视图。

根据本公开的第三方面，提供了一种适于接收场景的一个或更多个输入视图的编码系统，该编码系统包括：织锦产生器，适于基于该一个或更多个输入视图产生织锦图像和坐标图；以及编码器，适于将织锦图像和坐标图编码成比特流。

根据本公开的第四方面，提供了一种用于对与场景的一个或更多个输入视图关联的信息进行编码的方法，该方法包括：基于一个或更多个输入视图产生织锦图像和坐标图；以及将织锦图像和坐标图编码成比特流。

根据本公开的第五方面，提供了一种适于接收与场景关联的比特流并且产生一个或更多个输出图像的解码系统，该解码系统包括：解码器，适于根据该比特流解码织锦图像和坐标图，其中该织锦图像和该坐标图与场景的一个或更多个输入视图关联；以及视图产生单元，适于基于织锦图像和坐标图推导场景的一个或更多个输出图像。

根据本公开的第六方面，提供了一种用于对与场景的一个或更多个输入视图关联的信息进行解码的方法，该方法包括：根据该比特流解码织锦图像和坐标图，其中该织锦图像和该坐标图与场景的一个或更多个输入视图关联；以及基于织锦图像和坐标图推导场景的一个或更多个输入视图。

本公开的一个或更多个实施例的细节被陈述在附图和下面描述中。根据描述和附图并且根据权利要求将明白其它特征、目的和优点。

介绍

根据本公开的许多实施例，描述了用于代码化位于2-D和完全3-D表现之间的某处的图像/视频数据的系统和方法。使用硬件，在此描述的用于代码化图像/视频数据的系统和方法允许在规定体积(volume)内精确呈现任意的视图，这可以在双目(binocular)立体和自动立体显示以及其它应用中被利用。

在上述系统和方法的下限处，单个视图可以被表现，如在标准视频流中一样。在上限处，3-D环境/场景中的所有可见表面可以利用全角度(fullangular)颜色数据被代码化，根据任意体积内的内插的一组视图来表现几何形状和高光(specularity)。一些现代的图形硬件可以例如被有效地杠杆化(leverage)以便从任何允许的视点呈现环境/场景。

如在本公开中使用的，术语“代码化”指的是编码和解码两者。类似地，短语“代码化系统”包含编码系统和解码系统中的任一个或两个。

如在本公开中使用的，术语“环境”、“场景”和“世界”可以被可互换地使用。

如在本公开中使用的，术语“视点”和“视角”可以被可互换地使用并且在此被定义为从其观看场景的位置、角度和/或方向。术语“视图”、“视点图像”和“视角图像”可以被可互换地使用并且在此被定义为从特定视点看到/捕获的场景的一部分。

如在本公开中使用的，术语“视图平截头体”或“观看平截头体”在此被定义为可以从特定视点看到/捕获的场景中的空间体积。例如，空间的区域可以包括在源自特定视点的圆锥体或四棱锥之内看到/捕获的图像信息。

如在本公开中使用的，术语“质量”指的是客观的图像/视频质量和主观的图像/视频质量两者。客观的图像/视频质量通常可以被定量。(客观的)图像/视频质量的测量值的示例包括在期望图像和预测图像之间的畸变、图像信号的信噪比(SNR)、图像信号的峰值信号与噪声的比(PSNR)等等。

主观的图像/视频质量指的是如由图像/视频的观看者看到的图像的质量。虽然主观的图像/视频质量也可以使用图像/视频质量的客观的测量值来被测量，但是客观的图像/视频质量的增大不一定产生主观的图像/视频质量的增大，并且反之亦然。关于使用基于块的操作处理的图像，例如，主观的图像/视频质量考虑可以包含确定如何沿着块边界处理像素使得在最终显示的图像中减少块假像(artifact)的感知。对于图像的观察者，基于评价特征(诸如但不限于，图像中的各个特征的时间的连续性、细节、锐度、平滑度)进行主观的质量测量。

如在本公开中使用的，允许的视点指的是可以从代码化系统和方法可用的信息中直接提取和/或根据代码化系统和方法可用的信息呈现/导出来自其的信息的视点。类似地，允许的视图平截头体指的是在来自与场景关联的可用信息的约束的情况下在可以看到的场景中的空间的区域。

在本公开中提供的实施例可在用于适合于3-D特征的TV和媒体格式的编码和解码系统中被使用，其中可以在揭示先前遮蔽的场景的区域中利用来自新视图的信息。

这种格式的一种示例性的应用是在其中显示许多图像的自动立体显示中。例如，根据观看者位置可以观看图像的不同区域。另一个示例性的应用在自由视点TV技术中，其中观看者可以控制被递送用于显示的视点。其它的示例性的应用包括在增强现实(augmentedreality)中的使用，其中信息的图形被插入到3-D场景的2-D图像上(像道路信息、购物信息、Facebook联系人和历史信息)。3-D场景的2-D图像可以以其中视点可以改变(诸如基于3-D场景中的观看者的位置改变视点)的格式被传输。

这些示例性的成像应用可以包含在一些视图中遮蔽而在其它的视图中未遮蔽(disocclude)的信息。未遮蔽的信息在这些应用中可以相当显著。一种途径是发送与每个视点关联的视图。然而，要被发送以用于由代码化系统处理和代码化的视图的数量以及因此比特数可能不断增大。例如，自动立体显示可以利用从两个视点；到九个视点(这是典型的)；到超过三十二个视点的任何地方的信息。自由视点应用可以具有多个水平视图以及在一些版本中具有多个垂直视图。增强现实应用可以具有水平、垂直和变焦有关的视点。因此，要显示的每个视点的一个视图的代码化可以包含大量的比特和高计算复杂性。

本公开通过传输在平截头体之内包含许多视图的图像解决(address)遮蔽区域，使得传输的图像像最初卷绕(wraparound)场景对象然后可以被展开以用于代码化和传输的织锦一样。

基本帧编码

图1示出包含在视频的每一帧中的根据本公开的许多实施例的信息格式。在本公开中，该信息格式被称为术语“织锦”或“织锦信息”(参见参考文献[4]，其全部通过参考并入于此)。如图1所示，织锦信息包括在织锦图像A(105)和3-D世界坐标阵列B(110)中表现的信息。织锦信息还可以包括3-D照相机格子(cameragrid)(115)和校正层(120)，其中3-D照相机格子(115)和校正层(120)与织锦图像A(105)和3-D世界坐标阵列B(110)关联。可以例如根据MPEG类型差分的帧编码和压缩方案推导这个织锦信息。

织锦图像A(105)通常是像素数据的2-D阵列，其可以被表现为可以使用传统的2-D压缩方案编码的2-D图像(例如，矩形图像)。像素数据可以包含高动态范围信息(参见参考文献[3]，其通过参考全部并入于此)。织锦图像A(105)可以或者可以不看起来为传统的视角图像。例如，织锦图像A(105)中示出的特征可以看起来歪曲(warped)或者畸变，如在本公开(例如，图8)中稍后将示出的。

3-D世界坐标阵列B(110)包含与织锦图像A(105)中的像素关联的位置数据。在一个实施例中，3-D世界坐标阵列B(110)可以仅仅记录一个参数(例如，深度)，而在其它实施例中它可以记录两个参数(例如，深度加上水平偏移或视差)或者三个参数(例如，深度、水平视差和垂直视差)。

关于3-D世界坐标阵列B(110)使用的术语“视差”指示织锦图像A(105)中的特定像素已经从它在设定的默认视图中的位置移动了多少。这种默认视图可以例如作为输入(例如，人工输入)被提供，选自一个或更多个输入视图，或作为多个输入视图的平均或加权平均被自动地确定。因此，术语“视差”的这个使用提供特定像素处的局部图像歪曲的测量，其中稍后将在本公开(例如，图8)中示出图像歪曲。在仅仅具有水平拉伸/收缩的视图的情况下，3-D世界坐标阵列B(110)可以被坍塌(collapse)到包含关于深度和水平视差的信息的2-D世界坐标阵列。对于仅仅具有垂直拉伸/收缩的视图存在类似的情况。

在又一个实施例中，3-D世界坐标阵列B(110)可以包含与织锦图像A(105)中的每个像素对应的3-D世界坐标(例如，x、y和z)。实施例可以包含3-D世界坐标位置数据转换成等效深度加上视差数据(例如，水平和垂直视差)，并且反之亦然。

虽然包括诸如颜色和强度信息之类的视觉信息的织锦图像A(105)可以使用传统的2-D压缩方案被编码，但是3-D世界坐标阵列B(110)可以不顺从传统的2-D压缩方案。对于织锦图像A(105)和3-D世界坐标阵列B(110)中的每一个的压缩，可以使用无损压缩和可选地有损压缩来减少图像尺寸。然而，出于压缩目的，在视觉信息中应该被引起(accountfor)的误差(例如，能或不能被容忍的误差)通常不同于在坐标信息中应该被引起的误差。因此，3-D世界坐标阵列B(110)通常被与织锦图像A(105)不同地处理。

来自织锦图像A(105)的信息可以被用来呈现特定的视图并且通过从2.5-D场景帧投影到视图平截头体而从这些呈现的视图中的信息中去除可能存在于织锦图像A(105)中的上述歪曲/畸变方面中的一些或全部。

用于这种投影的一种示例性的方法被示出在参考文献[4]中。例如，像素可以使用3-D世界坐标阵列B(110)的3-D顶点和织锦图像A(105)的每个像素中包含的颜色值被连接成三角网格。齐次坐标(或类似的射影几何系统)可以被用来通过使用有限的坐标表现包括无穷远点的点的坐标。图形硬件然后可以被用来在规定极限之内将结果得到的三角网格重新投影到来自用户限定的视图的图像上。这些极限通常由3-D照相机格子(115)设定，该3-D照相机格子(115)提供允许的视图平截头体。

可替代地，点云呈现技术可以被用来直接呈现织锦图像A(105)中的像素(参见参考文献[1]，其通过参考全部并入于此)。

通常，可以不使用来自织锦图像A(105)中包含的完全任意的视图的信息来呈现织锦。一个原因在于整个场景通常不能以合理的分辨率在单个图像中(例如，通过单个视图)被表现。因此，要记录其信息的视图可以被选择为位于由允许的视图平截头体的3-D照相机格子(115)限定的凸包(convexhull)内。具体地，这些是通常根据特定应用设定的允许的(合法的)视点，其可以在织锦图像A(105)的产生中被代码化和利用。作为示例，立体系统通常允许至少两个视点(和与这些视点关联的两个视图平截头体)。在这两个视点之间和附近的视点通常也是允许的。

3-D照相机格子(115)中的每个点提供用于保持关于记录的视图的信息的3-D索引方案并且包含例如每个视图的视图位置、视图角、视图方向、取向(方向和向上向量(upvector))、以及水平和垂直尺寸等。换句话说，3-D照相机格子(115)上的每个点对应于特定视点及其关联的平截头体。因此，3-D照相机格子(115)提供用于指定视点及其关联的视图平截头体的方式/机构，并且可以从视点和由3-D照相机格子(115)上的特定点识别的关联的视图平截头体获得特定视图。3-D照相机格子(115)可以被组织化(organize)，例如，其中关于每个点的信息被包含在一维或多维阵列的元素内。

3-D照相机格子(115)典型地与稍后要在本公开中描述的可选的视图像素校正层(120)关联。在视图像素校正层(120)不由编码器产生和/或不由编码器提供给解码器的情况下，3-D照相机格子(115)仍然可以由编码器提供并且被应用以在织锦图像A(105)的解码期间约束视图移动。在没有来自3-D照相机格子(115)的数据的情况下，解码器可能没有认识到什么视图平截头体是“超越限度的”，因此产生具有不完整数据的视图。

在记录仅仅一个视图(例如，3-D照相机格子(115)具有1×1×1的格子尺寸)的情况下，可以呈现仅仅一个视图。对于这个情况通常不必利用3-D世界坐标阵列B(110)，这是因为代码化坍塌到代码化与单个视图关联的2-D视频流。

在选择呈现多视图并且因此记录来自多视图的信息的情况下，在通过来自所选的视图的结合的织锦图像A(105)中的像素的重新投影产生的呈现中通常存在误差。

通过示例的方式，这些误差可能起因于非兰伯特(Lambertian)反射、多个非遮蔽、以及由重新投影而引起的图像歪曲。为了校正这些误差，编码器可以为每个记录的视图平截头体提供校正层(120)，使得与编码器关联的解码器可以内插和校正预测视图和/或附近的视图。这些校正是可选的并且可以基于在考虑中的应用的规范(诸如比特率预算或计算复杂度约束)被阈值化(thresholded)或删节(elided)。

通过示例的方式，校正层(120)可以提供在根据织锦(105，110)产生的特定视图的呈现与对于特定视点捕获的对应图像之间的差别。3-D照相机格子(115)上的每个点因此可以与校正层(120)关联，其中校正层(120)可以与对应的产生织锦的视图一起被发送以用于代码化。校正层(120)可以被压缩以便提高传输的效率或保持未压缩，并且校正层(120)的这种代码化(例如，压缩)通常与织锦(105，110)自身如何被产生和限定无关。

双目立体

图2示出包括左视图(205)和右视图(210)的示例性的立体像对。

考虑右视图(210)被提供作为织锦图像A(图1中的105)。在单个视角图像(诸如右视图(210))中，三维的场景位置可以被编码为具有适合的照相机变换(transform)的深度图(z坐标)以便推导其它两个坐标(x坐标和y坐标)。具体地，可以在推导x和y坐标中利用深度值和照相机参数。

图3示出根据亮度映射的深度图的深度信息。具体地，与更远离右视图(210)的视点的原点的特征相比，更接近该原点的特征看起来更暗。这种深度图可以通过呈现工具被获得和/或使用视差转换方法从捕获的立体像对导出。介绍用于立体图像和视频的视差方法的示例性的参考文献被提供在参考文献[5]中，其通过参考全部并入于此。

深度图可以被认为像素动作的隐含的(implicit)表现并且可以提供关于像素通过位置重新投影从一个视图到另一个视图如何移动的信息。如果照相机参数已知，则可以计算视图之间的像素动作。具体地，像素动作指的是由视点的改变引起的特定像素的位置的改变。在立体视频内容的情况下，可以在左视图和右视图之间以及在视频内容的帧之间计算像素动作。

如从如图2所示的右视图(210)和如图3所示的深度图的观察明显的，深度信息通常在整个右视图(210)中是一致的，除了少量锐利的(sharp)边界之外。因此，由于通常一致的深度信息，可以利用压缩方案使得右视图(210)可以被压缩到比它的原始文件大小更小的文件大小。

图4示出通过将来自右视图(图2中的210)的图3中示出的深度图的信息与右视图(图2中的210)(用作织锦图像)自身一起结合而导出的左视图。如在图4中看到的，丢失所导出的左视图的少量区域(诸如区域405和410)。因此，图4中示出的导出的左视图是其中场景的部分由于从图2的右视图(210)的视点的改变而丢失的图2的左视图(205)的估计。

从关于图2-4中提供的各个图像/图的信息导出的校正层可以提供对于遮蔽和镜面高光的校正，该镜面高光作为使用右视图(图2中的210)及其关联的深度图(图3中示出)来产生左视图的结果而移动。通常，镜面高光的移动可以源于使用来自一个视图的信息以产生与另一个视图关联的信息。

应当注意，虽然根据本公开的许多实施例发送校正层，但是可以代替校正层的发送或者与校正层的发送结合地利用其它方法。例如，当比特预算不容许发送校正层时，诸如纹理区域填充(texturedareafilling)/修复(inpainting)之类的方法可以被使用。纹理区域填充/修复包含基于与特定位置相邻的位置处的可用的图像特性来预测图像的特定位置处的图像特性(例如，纹理、颜色等)。介绍用于基于深度的纹理填充的方法的示例性的参考文献被提供在参考文献[6](其通过参考全部并入于此)中，其中基于深度的信息在预测合成视图的未遮蔽区域中被利用。可以代替校正层的发送或者与校正层的发送结合地利用纹理区域填充/修复以及其它方法。

在本示例中(以及通常)，将深度图提供到代码化系统的成本(例如，传输深度图中的比特数)通常至少部分地通过左视图的改善的预测而被补偿。另外，应当注意，来自深度图的信息通过示例的方式并且没有限制地可以允许以适合的深度将闭合的字幕布置到图像中、虚拟字符的动态抠图(matting)等。

自动立体

自动立体显示利用多视图作为输入。视图的示例性的数量可以是十二个或更多个视图，以便在没有必要使用特殊眼镜的情况下示出立体和视差。利用与先前针对立体代码化描述的方法类似的方法，用于特定视图的一个织锦图像和与织锦图像关联的深度图可以被提供给代码化系统以便朝向特定视图的左和右推导一个或更多个视图。特定视图可以是例如中心视图。

认为织锦图像为以汽车的正面为中心的中心视图并且待确定的视图是最左边的视图。具体地，在该示例中，利用中心视图来推导最左边的视图。

图5A和5B分别示出导出的最左边的视图和与导出的最左边的视图关联的一个可能的校正层。导出的最左边的视图示出汽车的不能通过中心视图看到的部分。然而，应当注意，与对于图4的导出的左视图示出的误差(405，410)相比，导出的最左边的视图示出更大的误差(诸如区域505和510)。原因在于与和图5A的导出的最左边的视图关联的左视图相比，图4的导出的左视图与更接近中心视图的左视图关联。通常，与相对于设定的中心视点更发散的视点导出的视图关联的误差大于更接近设定的中心视点的视点导出的视图。

虽然图5B中示出的校正层可以被提供给解码器以用于修复这些区域(诸如图5A中的505和510)，但是校正层的传输要求比特和带宽。另外，在许多应用中，需要推导多视图，并且因此通常需要多个校正层来通过使用合理的比特数和合理的带宽量覆盖这些视图。

应当注意，可以使用诸如动作估计(例如，在不同视图之间的特定像素的像素动作)之类的预测方法根据推导出的视图的内插导出特定视图。还应该注意，校正层自身可以通过基于产生的校正层执行预测方法经由内插被预测。

如前面所提到的，织锦可以从3-D场景(现实世界或者人造的)捕获信息并且将信息映射到有用的比特中，可以从该有用的比特提取和/或推导图像。图6示出与两个视图(视图1(605)和视图2(610))对应的视图平截头体的顶视图的示例。具体地，图6示出两个视图平截头体的截面。两个视图(605，610)可以例如是左视图(例如，来自左眼)和右视图(例如，来自右眼)，但是这两个视图可以为任何两个任意的视图。图6中的场景包括对象(615)和墙壁(620)，其中墙壁(620)可以被认为是场景的背景。

对象(615)的一侧可以仅仅在视图1(605)中被看到，而对象(615)的其它方面(例如，对象(615)的正面)可以仅仅从视图2(610)看到。存在视图1(605)独有的墙壁的区域(625，635)、视图2(610)独有的沿着对象(615)的区域以及可以从两个视图(605，610)看到的区域(630)。

在基于两个视图(605，610)形成织锦中，冗余信息(诸如区域630中的)可以被最小化而每个视图独有的区域/对象(例如，对于视图1的625、635以及对于视图2的615)可以通过织锦被捕获。来自两个视图(605，610)的信息的结合可以形成包含歪曲的场景的结合的图像(如稍后图7D所示出的)。

图7A和7B示出根据第一视点和第二视点获得的场景的视图。该场景包括棋盘(checkerboard)背景和平行六面体。图7C示出包括分别来自图7A和7B的第一和第二视图两者的信息的视角图像。图7C中的黑区(705，710)与不能从图7A和7B中的两个源视图中的任意一个看到的场景的区域关联。

应当注意，黑区(705，710)示出平行六面体已经被确定位于离开棋盘背景一定距离处并且由于该距离呈现器已经识别平行六面体和棋盘背景作为分离的(disjoint)几何形状。在这种情况下，该距离可以大于设定的阈值，其导致棋盘背景和平行六面体被彼此分离地呈现。稍后将在本公开中进一步描述阈值和分离的几何形状。

图7D示出可以根据图7A和7B的第一和第二视图一起产生的一个可能的织锦图像。具体地，图7D示出来自第一和第二视图两者的信息的结合，因此第一和第二视图可以从图7D的的图像导出。图7D的织锦图像还可以被用来产生除了第一和第二视图以外的其它视角图像，其一个示例被示出在图7C中。

作为另一个示例，图8示出包括来自多个视角的信息的图像；该图像因此可以被称为多视角图像。该信息适合于产生与包含在多视角图像中的视点关联的视图以及不一定包含在多视角图像中的视图。参考文献[2](其通过参考全部并入于此)是涉及诸如图8中示出的图像之类的多视角图像的示例性的参考文献。在下面讨论中图8的多视角图像将被用作织锦图像。

织锦图像可以在考虑使来自产生织锦图像中利用的各个视点之间的冗余信息最小化的情况下被产生。例如，与离开中心视点1°的视点关联的视图通常类似于中心视点并且还类似于与离开中心视点2°的视点关联的另一个视图。因此，当产生织锦图像时来自这三个视点的冗余信息可以被最小化。

这个织锦图像对于眼睛看起来陌生。然而，可以对于这个特定织锦图像进行一些观察。首先，织锦图像可以被创建为将较多图像区域分配在汽车(其通常是注视点)上，而将较少区域分配在图像的各种其它区域(其可以一起被称为背景)上。在关于汽车的信息更多的情况下，可以获得对于每个输出视图的前景的更锐利的推导/呈现。第二，织锦图像的线性扫描覆盖许多角度和视图(其可以涉及自动立体显示)，因此示出可能在任何单个视角图像中丢失的汽车的部分。如前面所提到的，织锦图像中的每个像素可以与特定视图或者从其获得或者导出该特定像素的视图关联。

对图像/视频的特征的重要性的分配可以被人工地执行(例如，用户选择视频内容的重要的特征)或者自动地确定。可以利用频率分析，诸如在图像压缩期间通常执行的频率分析。例如，织锦图像可以利用频率分析引导的歪曲，其中织锦图像中的更大区域被分配用于高频信息。重要性的确定还可以基于评价视频内容中的不同特征的显著度(saliency)。可以代替例如频率或显著度引导的歪曲或者与例如频率或显著度引导的歪曲结合地执行织锦图像的直接/人工歪曲。

图9A-9C示出与图8中示出的多视角图像对应的3-D世界坐标。3-D世界坐标可以被用来重新投影来自图8中示出的织锦图像的像素以便推导给定应用中可能需要的在中间的任何视图的估计值。可能不需要传输多于织锦图像和3-D世界坐标阵列来产生与特定自动立体系统要求的一样多的视图。

如上所述，图8中示出的织锦图像不是单个视角图像。具体地，图像视角(例如，视点)随着织锦图像中的像素位置改变并且因此3-D世界坐标(例如，x、y、z)必须为每个像素位置提供以便将织锦图像中的每个像素与场景中的实际位置关联。结果，织锦中的每个像素包含颜色(或者强度)信息以及3-D坐标信息，其中颜色(或者强度)信息可以被存储在织锦图像A(图1中的105)中并且3-D坐标信息可以分别被存储在3-D世界坐标阵列B(图1中的110)中。

图9A-9C描绘用于图8的织锦图像中的每个像素的3-D坐标信息的示例表现。在该实施例中，x、y和z坐标信息首先被规格化(normalize)到范围(例如[0，1]或者[0，255])，并且随后它与任意的颜色通道(例如，R、G或者B)关联。例如，蓝色通道中的较高值可以与较高的z坐标值(相对于设定的原点)关联。众所周知，图9A-9C中的信息(表现分别映射到R、G和B的示例)可以被结合成一个图像使得该图像中的每个像素与R、G和B(例如，x、y和z)值关联。应当注意，每个位置坐标到颜色值的映射是任意的并且主要出于可视化目的。

在其中仅仅允许水平视图动作或者仅仅允许垂直视图动作的实施例中，3-D世界坐标可以被坍塌到表现对于织锦图像中的每个像素的水平或垂直视差以及深度的2-D世界坐标。

在一个实施例中，3-D世界坐标阵列可以以具有像素位置偏移的深度值形式被编码。相对于当前帧的视图参数，这种代码化允许3-D坐标被导出并且可以提供在解码硬件中的支持和压缩方面的好处。对于低成本的解码硬件，例如，像素位置偏移可以和深度缓冲器一起使用以便确定对于给定帧绘制(draw)哪些像素，而没有必要包含任何视角矩阵计算。

图10A-10C示出根据图8和9A-9C中示出的织锦制作的三个示例性的呈现。具体地，左、中心和右视图分别被示出在图10A-10C中。如前面所提到的，可以根据单个图像产生多视图。很少的误差与汽车自身关联，但是一些误差存在于(通常更不)重要的背景(诸如图10A中的区域1005和1010，图10B中的1015和1020，图10C中的1025和1030)。这些误差可以使用纹理填充/修复和校正层中的一个或更多个被校正。可替代地或相结合地，其中捕获更多背景的更宽的织锦图像的使用可以减少误差。出于此目的可以开发自动化方法。

呈现诸如这个之类的织锦可以通过如图11所示的对3-D世界坐标和像素的阵列执行3-D网格呈现方法来实现。如本领域技术人员已知的，图11提供可以被用于根据图像信息(例如，具有它的对应深度信息的2-D图像)产生3-D网格的用于3-D网格呈现的示例性方法。例如，在3-D网格呈现中利用高洛德着色(Gouraud-shaded)呈现的情况下，3-D世界坐标和像素的阵列可以被结合成高洛德着色的四边形的阵列。

参考图11，织锦(例如，织锦和3-D世界坐标)中的每个像素(1110)包含关于与像素关联的颜色信息(例如，R、G、B)和3-D坐标(例如，x、y、z)的信息。每个像素被缝合(stitch)成多边形条(polygonalstrip)(1120)以便形成3-D网格(1130)。虽然三角形的条是常见的，但是也可以利用诸如四边形之类的其它多边形。在存在较大3-D不连续性(例如，其中信息不足或不可用的位置)的情况下，可能出现3-D网格(1130)中的间隙。3-D网格(1130)的额外的3-D呈现(1140)(诸如但不限于高洛德着色呈现(1140))可以(但不必)对3-D网格(1130)执行以便内插3-D网格(1130)中的信息并且因此平滑化存在于3-D网格(1130)中的多边形。输出图像(1150)可以由3-D网格自身(1130)形成或者由呈现(1140)之后的3-D网格形成。

创建织锦

因为图8处理虚拟场景，所以图8提供其中场景的信息可以被假设为完整的情况。在现实世界场景中，为了获得关于多个视图的信息，可以采用如下照相机，该照相机具有布置成一条线的多个视角，诸如在自由视点TV技术中，或者类似地包括多个照相机(每个捕获特定视角)的一条线。可以根据从一个或多个照相机捕获的图像产生织锦图像和估计的世界坐标。这被称为多视图立体，并且对于根据这种捕获图像推导场景位置，存在计算机视觉算法。

除了根据捕获的视图获得织锦图像和估计的场景坐标之外，可以使用捕获的视图作为参考计算视图像素校正层。校正层暗示从织锦图像到捕获的视图中的每一个的具体的映射。因此，与织锦图像和估计的世界坐标关联的3-D照相机格子变为与捕获的视图对应的单线的视图，其允许沿着用户定义的目标视差宽度呈现需要的任何视图。通常，织锦的基础分辨率高于要呈现的目标视图的分辨率。校正层可以被应用于导出的目标视图，使得导出的目标视图与对应于相同的视点的那些参考更紧密地匹配。

如先前注意的，诸如但不限于纹理区域填充/修复之类的方法可以与校正层的利用结合或者作为对于校正层的利用的替代方案而被利用。例如，在解码器接收来自校正层的不足的信息、不足数量的校正层的情况下，和/或当对于其存在不足的信息或者不存在信息的特定视图中存在像素时，可能需要利用和/或推导其它图像信息。校正层中的一个或更多个中的信息可以基于诸如纹理区域填充/修复之类的方法被内插和/或推导。在没有校正层被提供给解码器的情况下，这些方法可以被利用作为撤退(fallback)方法以便基于提供给解码器的信息推导用于任何期望视图的信息。

图12A示出根据来自三个视图的信息的结合产生的织锦图像。图12B-12D中的每一个示出了与图12A的织锦图像关联的3-D世界坐标图的一维。如图9A-9C中一样，出于可视化目的将x、y和z坐标中的每一个映射到红色(R)、绿色(G)和蓝色(B)通道。虽然从虚拟/合成场景导出织锦，但是还可以已经通过使用例如一个或更多个照相机从真实环境的各个视点拍摄图片来捕获用于推导织锦的信息。

类似于图8，陌生的(从主观的观点)歪曲示出包含的畸变以便包括关于仅仅从特定视角可见的汽车和背景的部分的信息。图12A的织锦图像中的每个像素与来自图12B-12D中提供的3-D世界坐标图的坐标的关联可以使得能够在从图12A-12D中提供的织锦信息呈现/推导各个视点期间去除这个畸变。

图13A-13C示出了根据图12A和12B的织锦产生的视图的示例。具体地，图13A-13C分别示出了左视图、中心视图和右视图。如图13A-13C所示，织锦提供信息以便产生汽车和背景的许多区域，但是一些误差(例如，1305，1310)是明显的。

图14示出了用于产生织锦信息和编码视频信息(包括织锦信息在内)的示例性的编码系统(1400)。对于要编码的视频，用于视频的每个帧的输入包括N个输入视角图像(1405)和N个深度图(1407)，其中每个输入视角图像与深度图关联。N个输入视角图像(1405)有效限定“场景”或者“世界”。

可以可选地提供包含与N个视点有关的信息的3-D照相机格子(1410)和与输入视角图像(1405)对应的平截头体以用于编码。如前面所提到的，3-D照相机格子(1410)可以包括关于允许的视点和平截头体(诸如对应平截头体和每个视点的边界)的信息。应当注意，输入视角图像(1405)以及因此与输入视角图像(1405)关联的3-D照相机格子(1410)和深度图(1407)可以被捕获(例如，直接地来自照相机)和/或被推导(例如，基于捕获的视角图像和/或其它导出的视角图像被呈现)。

输入视角图像(1405)以及与输入视角图像(1405)关联的深度图(1407)在使用织锦产生单元(1415)创建织锦(1415)中被利用。织锦产生单元(1415)的输出包括织锦图像A(1420)和3-D世界坐标阵列B(1425)，其中A(1420)和B(1425)两者与通过输入视角图像(1405)和对应深度图(1407)限定的场景/世界关联。织锦产生单元(1415)可以基于诸如所选的输出视图或多个视图以及织锦的分辨率之类的输入参数创建织锦。此外，可以基于输入参数设定对于如何分配织锦图像中的区域的确定(诸如基于人工、基于显著度和/或基于频率)。

应当注意，深度图(1407)可以被直接提供给织锦产生单元(1415)或织锦产生单元(1415)可以推导深度图(1407)。例如多视图立体匹配算法可以被用于推导用于图像中的像素的3-D位置数据，其中3-D位置数据包括深度值和/或可以被映射到深度值的数据。

来自输入视角图像(1405)的信息以及关联的3-D照相机格子(1410)(如果可应用)可以被提供给呈现单元(1430)，其基于输入信息(1405，1410)产生(1430)重新呈现的输入视图。这些重新呈现的输入视图是输入视角图像(1405)的预测/估计。因此，经由减法单元(1435)获得差别(1435)产生了包括残差信息的校正层(1440)。每个校正层(1440)对应于一个输入视角图像(1405)。应当注意，通过编码器侧上的呈现单元(1430)利用(例如，量化(quantization))的精度和执行的操作通常类似于对于解码器侧上的呈现单元的那些。

与3-D照相机格子(1410)、织锦图像A(1420)、3-D世界坐标阵列B(1425)和校正层(1440)有关的信息可以被提供以便通过使用编码器(1445)被编码成比特流(1450)。比特流(1450)适于被传输到解码器并且由解码器(例如，图15中示出的)解码。虽然一个比特流(1450)被示出在图14中，但是编码器(1445)可以把各个信息编码成多个比特流。作为示例，第一比特流可以包含来自织锦图像A(1420)和3-D世界坐标阵列B(1425)的织锦信息；第二比特流可以包含来自校正层(1440)的信息；并且第三比特流可以包含来自3-D照相机格子(1410)的信息，其可以被编码为元数据并且与第一和第二比特流一起传输。

应当注意，编码器可以但不必产生校正层(1440)并且编码和传输3-D照相机格子(1410)和校正层(1440)。

图15示出了被配置为对来自图14的示例性的编码系统的信息进行解码的示例性的解码系统(1500)。比特流(1550)(诸如图14中也示出的)将输入提供给解码系统(1500)。比特流(1550)适于经由解码器(1545)被解码。可以根据比特流(1550)解码织锦图像A(1520)、3-D世界坐标阵列B(1525)、以及如果可用的话3-D照相机格子(1510)和校正层(1540)。可以跟随多个处理以便产生输出图像(1565，1570)。如对于编码器侧注意的，解码器侧也可以从编码器接收多个比特流。

包括织锦图像A(1520)和3-D世界坐标阵列B(1525)的织锦信息可以由3-D网格呈现单元(1560)呈现为3-D网格(1560)。图11中提供的用于3-D网格呈现的示例性方法可以在产生3-D网格呈现单元(1560)的输出中被利用。来自3-D网格呈现单元(1560)的3-D网格(1560)可以用作解码系统(1500)的输出图像(1565)。

可选地，来自3-D照相机格子(1510)和校正层(1540)的信息也可以在产生输出图像(1570)中被利用。这种信息(1510，1540)可以在呈现、校正和重新投影来自与输出图像(1570)关联的一个或更多个视图的信息以便形成输出图像(1570)中被利用。来自3-D照相机格子(1510)和校正层(1540)的信息的利用通常可以产生更高图像质量(例如，更少误差)的输出图像。

返回参考图14，如下提供用于产生包括织锦图像(1420)和3-D世界坐标图(1425)的织锦的示例性的方法。

初始步骤包括从与输入图像(1405)关联的视角之中选择默认视图。这个默认视图可以例如作为输入被给出，选自一个或更多个输入视图，或者作为多个输入视图的平均或加权平均被自动地确定。

来自每个输入视图的三维世界坐标可以被重新投影到默认视图中，结果得到多深度图像。默认视图中的每个像素可以基于与像素关联的深度图的值被分类到特定深度层或深度台阶(step)。与哪个输入视角图像(1405)可以看到特定深度层/台阶有关的信息可以被产生。深度层/台阶的示例性的数量是八个(例如，其中0最接近中心视角的原点并且8是最远的)。然而，可以利用更多或更少的深度层/台阶。

对于默认视图输出图像中的每个像素，投票(vote)(也被称为提供/推导权重或偏好(preference))被执行以便从输入视角图像(1405)之中推选(elect)一个或更多个视角图像。推选一个或多个视角图像的一种示例性方法是，推选具有到与默认视图输出图像中的特定像素关联的深度层最多/最近的点的那些图像。

对于所推选的图像，沿着与这个默认视图处的最近和最远的点的分离对应的矢量，对于与所推选的图像关联的视角视图记录偏好，如在所推选的视图中看到。执行前景像素到输出像素位置的2-D偏移的记录以便把所推选的视图锚定(anchor)到默认视图输出图像中的该特定像素。

对于默认视图输出图像中的每个像素，平均偏移可以被计算并且优选视图(也被称为最流行视图)可以被计算并且选自先前收集的统计值(statistics)。可以通过跟踪光线(tracingray)到被处理为高度场(heightfield)的图像中，来呈现特定像素处的优选视图的3-D坐标和实际像素颜色。

用于创建织锦的示例性的方法被提供于在此附上作为附件A的代码中，该附件A形成本公开的不可分割的部分。通常，要用于推导一个或更多个视点的织锦应该是可见场景像素的连接的图，其中更大图像区域被分配给更锐利地聚焦的和/或更重要的区域。这种织锦的产生通常包含以多个维度解决约束过少的(underconstrained)优化问题。结果，存在用于改善等式(equation)的编码侧和捕获的许多机会。

应当注意C代码被提供作为示例。织锦创建方法中的步骤可以以任何主要编程语言(诸如Perl、Python、C++、Java、Fortran等)被书写，并且可以被实现以便在单独的PC和多节点群集两者上运行。根据本公开的算法和方法的可执行步骤可以被存储在介质、计算机、或计算机可读介质上。各个步骤可以以多个处理器模式或单个处理器模式被执行。所有程序应该能够在最小修改的情况下在大多数单独的PC上运行。

有用的特性

通常，因为织锦图像(诸如图8和12A中示出的那些)包含歪曲以及有时遮蔽的图像信息，所以织锦图像可以允许基于织锦图像中的图像像素的不成比例的分配的分辨率的局部调整。这种分辨率的局部调整可以允许图片中的重要的细节(例如，脸)的信息的分配而同时牺牲场景的周边和离焦区域中的分辨率。

例如，可以从多个视角捕获脸部特写中的信息。虽然织锦图像会可能是歪曲的(类似于图8和12A中示出的那些)，但是织锦图像可以基本上卷绕被摄体的头使得重新投影可以输出与被摄体的头有关的高细节/分辨率图像。关于被摄体的脸、左耳朵和右耳朵的信息可以被捕获在从织锦导出的图像中，几乎好似脸和耳朵全部直接埋进(facinginto)照相机中。与从3-D照相机格子中的任何一个或多个视图直接地呈现的情况下相比，脸部特写可以看起来更大和/或具有更高细节/分辨率，并且可以包括来自多个视点的信息。与此对比，与根据从织锦直接地产生(在没有调整的情况下)的最终视图直接地呈现的情况下相比，不重要的背景可以获得更少区域并且看起来更未聚焦，这是因为对于背景通常需要更少分辨率，特别在它不清楚时。

除了为像素重新投影提供几何形状信息之外，3-D世界坐标阵列提供关于源于改变视点的像素动作的直接信息，其可以被代码化系统利用来改善性能(例如，计算复杂性，精度和比特率)。通过利用3-D希耳伯特遍历(Hilberttraversal)排序(order)视图校正层，MPEG编码也可以被用来减少这个数据子集的占地面积(footprint)。

分离的几何形状

小的分离的几何形状如果不小心地处理则可以导致输出图像中的可见性误差。输出图像中的每个像素与深度值关联。参考图13A-13C，棋盘背景和汽车之间的深度值的不连续性产生与棋盘背景关联的一组多边形应该与和汽车关联的一组多边形分离的确定，并且因此这些组多边形不应该被缝合在一起。将这些组多边形缝合在一起会导致汽车附接于汽车后面的棋盘背景。

阈值可以被利用来确定是否存在足够大的不连续性。这种确定确定了特定多边形是否应该被缝合在一起。例如，如图13A-13C所示，在连接的网格中对于所有视图汽车上的天线不能被表现，这是因为这种连接将创建从天线附接到天线后面的表面的大的三角形(1305，1310)。

用于处理这种误差的一种示例性的方法是设定距离阈值，在该距离阈值之上特定几何形状被认为分离并且分隔地呈现。如先前描述的，可以从连接(并且不连接)各个多边形(例如，四边形、三角形等)来形成网格。如果图像的两个方面(例如，前景中的汽车以及背景中的墙壁)之间的距离大于设定的距离阈值，则多边形不被连接并且特定方面被认为分离并且分隔地呈现。

如示出的，天线在1305和1310处连接到汽车，其表示汽车的部分和天线之间的深度差在阈值之下，而天线不连接到棋盘背景，其表示天线和棋盘背景之间的深度差在阈值之上。在没有利用特定方法来处理这种小的分离的几何形状的情况下在呈现期间校正这些误差将通常是计算上和存储昂贵的。

另一种示例性的方法是留出(setaside)脱离织锦内的主图像的织锦的某一区域，其中这种信息(例如，纹理、几何形状等)可以被存储。用于存储分离/脱离的信息的区域的示例可以是图11的1130中的那些不连接的区域。围绕这个分配的区域的区域将被设置有特殊的或非法的值以便破坏它与主图像的连续性。该区域可以被存储例如在织锦的周边中以便不破坏被认为连续的主图像的部分。

这个区域相对于主图像的其它部分通常是小的，因为小的几何形状通常可以被安全地表现为连续的，即使在除非小的几何形状碰巧非常接近于视图平截头体的原点才不是的情况下。在这种情况下，几何形状通常被认为足够大和/或足够重要来批准(warrant)织锦中的更大区域。在一些情况下，当大的几何形状看起来快速移动和/或模糊时可以为大的几何形状提供更低分辨率。因此，返回参考图13A-13C，织锦图像中的区域可以被分配以便将天线表现为分离的几何形状。

如先前讨论所示，织锦图像和它的对应3-D世界坐标可以被用来产生各个视图的估计。这种图像可以被用来形成电影，其中观看者可以从织锦允许的无论什么视点观看一系列的图像。表现整个场景或其部分可以包含使用或产生附加信息(诸如用于场景的光源(例如，基于图像的照明环境)的放置)或动态地呈现其它对象到场景中。

在本公开中描述的方法和系统可以被实现在硬件、软件、固件或其组合中。描述为块、模块或元件的特征可以被一起实现(例如，在诸如集成逻辑装置之类的逻辑装置中)或分离地实现(例如，作为分离的连接的逻辑装置)。本公开的方法的软件部分可以包括计算机可读介质，其包括在运行时至少部分执行描述的方法的指令。计算机可读介质可以包括例如随机访问存储器(RAM)和/或只读存储器(ROM)并且可以是磁性的和/或光学的。指令可以由处理器(例如，数字信号处理器(DSP)、专用集成电路(ASIC)或现场可编程逻辑阵列(FPGA))运行。

在该说明书中提到的所有专利和出版物可以表示本公开所属的领域中的技术人员的技能水平。在本公开中引用的所有参考文献通过参考被并入到如每个参考文献已经各自地通过参考全部被并入一样的相同的程度。

上面陈述的示例被提供以便给予本领域技术人员对于如何制作和使用本公开的使用织锦编码的多视图图像的表现和代码化的实施例的完整的公开和描述，并且不意图限制发明人把什么当做它们的公开的范围。用于实现本公开的上述的模式的修改可以由视频领域中的技术人员使用，并且意图在以下权利要求的范围内。

应当理解，本公开不限于特定方法或系统，其当然可以改变。同样，应当理解，在此使用的术语仅仅出于描述特定实施例的目的而不意图是限制性的。如在本说明书和所附权利要求中使用的，除非内容清楚地规定否则单数形式“一”、“一个”和“该”包括多个涉及的对象。除非内容清楚地规定否则术语“多个”包括两个或更多个涉及的对象。除非有定义，否则在此使用的所有技术的和科学的术语都具有与本公开所属的领域中的技术人员通常理解的意思相同的意思。

已经描述了本公开的许多实施例。然而，应当理解，在不脱离本公开的精神和范围的情况下可以进行各种修改。因此，其它实施例在以下权利要求的范围之内。

参考文献的列表

[1]J.P.Grossman，WilliamDally，″PointSampleRendering″，RenderingTechniques′98，Proceedingsofthe1998EurographicsWorkshoponRendering.

[2]PaulRademacherandGaryBishop,"Multiple-Center-of-ProjectionImages",ProceedingsofSIGGRAPH'98,websiteaccessedSeptember28,2011.

http://www.paulrademacher.com/unc/papers/Rademacher-mcop98.pdf

[3]ErikReinhard,GregWard,SumantPattanaik,PaulDebevec,HighDynamicRangeImaging:Acquisition,Display,andImage-basedLighting,MorganKaufmannPublishers,2005.

[4]MaryannSimmonsandCarloSéquin,"Tapestry:DynamicMesh-basedDisplayrepresentationforInteractiveRendering",EurographicsWorkshoponRendering2000.

[5]M.Lang,A.Hornung,O.Wang,S.Poulakos,A.Smolic,andM.Gross,"NonlinearDisparityMappingforStereoscopic3D"(July2010).ToappearinACMTransactionsonGraphics(Proc.SIGGRAPH).

[6]K.J.Ohetal.,"Hole-FillingMethodUsingDepthBasedIn-paintingforViewSynthesisinFreeViewpointTelevisionand3DVideo"(2009).Proc.PictureCodingSymposium(PCS),pp.1-4.

2011DolbyLicensingCorporation(17USC401).

附件A

/*mktapestry.h

*

*对于织锦建造器的内部和外部。

*(假设已经加载<stdio.h>)

*

*由GregWard于2/28/11创建。

*版权2011DolbyLaboratories。保留所有权利。

*

*/

#ifndef_MKTAPESTRY_H_

#define_MKTAPESTRY_H_

#include"rtmath.h"

#include"color.h"

#include"view.h"

#ifdef_cplusplus

extern"C"{

#endif

/*具有深度缓冲器的核内或存储器映射的图像*/

typedefstruct{

charfname[64]；/*文件名*/

VIEWvw；/*图像视图*/

RESOLUrs；/*图像尺寸和取向*/

doublep2h,p2v；/*我们的视图尺寸与母尺寸的比例*/

doubleexpval；/*对于图片的曝光值＊/

charfmt[32]；/*图片格式*/

uby8*pmap；/*存储器映射的图片原点*/

COLR*pimg；/*RGBE图像的开始*/

float*dimg；/*深度图像的开始*/

floatdrng[2]；/*深度最小值和最大值*/

uby8*dfli；/*深度标记图像(parentres.)*/

float*pref；/*其中我们优选(inparent)*/

}InPicture；

#defineTPcolrScan(p,y)((p)->pimg+scanlen(&(p)->rs)*(y))

#defineTPdpthScan(p,y)((p)->dimg+scanlen(&(p)->rs)*(y))

/*用于构建织锦的主结构*/

typedefstruct{

VIEWtvw；/*织锦目标视图*/

RESOLUtrs；/*织锦目标尺寸*/

doublepixaspect；/*目标像素纵横比*/

uintl6*edbuf[8]；/*经编码的多深度缓冲器*/

float(*offs)[2]；/*对于最佳视图的delta(x,y)的和＊/

intninp；/*输入图片的数量*/

InPictureinp[l]；/*输入图片(扩展结构)

*/

}TapestryObj；

#defineTPedScan(t,m,y)((t)->edbuf[m]+scanlen(&(t)->trs)*(y))

#defineTPoffsum(t,x,y)(t)->offs[scanlen(&(t)->trs)*(y)+(x)]

#defineTPdfScan(t,i,y)((t)->inp[i].dfli+scanlen(&(t)->trs)*(y))

#defineTPprScan(t,i,y)((t)->inp[i].pref+scanlen(&(t)->trs)*(y))

externdoubleTPviewDistance(constVIEW*v1p,constVIEW*v2p)；

externintTPpicNearest(int*parr,intlen,constVIEW*vp,constTapestryObj*tp)；

externintTPmapLocation(FVECTloc,

constVIEW*vsrc,constVIEW*vdst)；

externintTPencodeDepth(doubledpth)；

externdoubleTPdecodeDepth(intdc)；

/***************************************************************

*

*下面给出应用调用。

*

*简单的调用序列为：

*tp＝TPnewTapestry(n)；

*for(i＝0；i<n；i++)

*TPopenPicture(TPinp(tp,i),pname[i],zname[i])；

*TPrenderTapestry(hdr_name,pt3_name,tp,imgwidth,imgheight)；

*TPfreeTapestry(tp)；

*

*大多数调用返回NULL，除非存在致命错误，

*在该情况下返回英语消息。在除TPfreeTapestry()之外返回错误之后

＊没有调用应该被进行。

*/

/*用于返回指针到第i个输入图片的宏*/

#defineTPinp(t,i)(&(t)->inp[i])

/*为ni个输入图像分配织锦对象*/

externTapestryObj*TPnewTapestry(intni)；

/*打开RadianceRGBE(或XYZE)图片和关联的深度缓冲器*/

externconstchar*TPopenPicture(InPicture*ip,constchar*pname,constchar*zname)；

/*给定输入图片已准备好？*/

externintTPpicReady(constInPicture*ip)；

/*选择最接近打开图片的平均值的视图*/

externconstVIEW*TPcentralView(constTapestryObj*tp)；

/*将我们的输入视图映射到默认视图中，记录多个深度*/

externconstchar*TPmapPictures(TapestryObj*tp)；

/*确定织锦中的每个像素处的最佳视图*/

externconstchar*TPchooseViews(TapestryObj*tp)；

/*输出完整的织锦和(可选地)3-D坐标图像*/

externconstchar*TPoutputTapestry(constchar*pname,constchar*cname,TapestryObj*tp)；

/*结合的织锦创建和呈现

*由TPcentralView()选择默认视图。

*如果xres和yres为0，则从第一输入获得分辨率。

*调用TPmapPictures()、TPchooseViews()，然后TPoutputTapestry()。

*释放所有临时缓冲器但是留下输入打开。

*/

externconstchar*TPrenderTapestry(constchar*pname,constchar*cname,TapestryObj*tp,intxres,intyres)；

/*释放织锦对象，关闭所有输入文件并且清除存储器*/

externvoidTPfreeTapestry(TapestryObj*tp)；

#ifdef__cplusplus

}

#endif

#endif/*_MKTAPESTRY_H_*/

/*

*mktapestryl.c

*

*根据一组Radiance图片和z缓冲器

*创建织锦图像和3-D世界坐标缓冲器。

*

*初始化，共享的功能，结合的调用

*

*由GregWard于2/28/11创建。

*版权2011DolbyLaboratories。保留所有权利。

*

*/

#include<stdio.h>

#include<string.h>

#include<unistd.h>

#include<fcntl.h>

#include<sys/mman.h>

#include"mktapestry.h"

/*为ni个输入图像分配织锦对象*/

TapestryObj*

TPnewTapestry(intni)

{

TapestryObj*ntp；if(ni<＝0)returnNULL；

ntp＝(TapestryObj*)malloc(sizeof(TapestryObj)+sizeof(InPicture)*(ni-1))；

if(ntp＝＝NULL)returnNULL；

ntp->tvw＝stdview；

ntp->trs.rt＝PIXSTANDARD；

ntp->trs.xr＝1920；

ntp->trs.yr＝1920；

ntp->pixaspect＝1.；

memset(ntp->edbuf,0,sizeof(ntp->edbuf))；

ntp->offs＝NULL；

memset(ntp->inp,0,sizeof(InPicture)*ni)；

ntp->ninp＝ni；

returnntp；

}

/*释放/卸载特定图像*/

staticvoid

TPclosePicture(InPicture*ip)

{

if(ip->dfli！＝NULL){

free(ip->dfli)；

ip->dfli＝NULL；

}

if(ip->pref！＝NULL){free(ip->pref)；

ip->pref＝NULL；

}if(ip->pmap！＝NULL){munmap(ip->pmap,((uby8*)ip->pimg-ip->pmap)+

sizeof(COLR)*ip->rs.xr*ip->rs.yr)；

ip->pmap＝NULL；

ip->pimg＝NULL；

}

if(ip->dimg！＝NULL){munmap(ip->dimg,sizeof(float)*ip->rs.xr*ip->rs.yr)；

ip->dimg＝NULL；

}

}

/*释放织锦对象，关闭所有输入文件并且清除存储器*/void

TPfreeTapestry(TapestryObj*tp)

{inti；for(i＝8；i--；)

if(tp->edbuf[i]！＝NULL)

free(tp->edbuf[i])；

if(tp->offs！＝NULL)

free(tp->offs)；

for(i＝tp->ninp；i--；)

TPclosePicture(&tp->inp[i])；

free(tp)；

}

/*给定输入图片已准备好？*/

int

TPpicReady(constInPicture*ip)

{

if(ip->pimg＝＝NULL)

return0；

if(ip->dimg＝＝NULL)

return0；

if(！ip->vw.type)

return0；

if((ip->rs.xr<＝0)|(ip->rs.yr<＝0))

return0；

return(ip->expval>.0)；

}

/*从Radiance报头和记录信息得到线*/

staticint

TPheadLine(char*ln,void*p)

{

InPicture*ip＝(InPicture*)p；

if(isexpos(ln)){ip->expval*＝exposval(ln)；

return(ip->expval>.0)？0:-1；

}

if(isview(ln)){sscanview(&ip->vw,ln)；

return0；

}

if(formatval(ip->fmt,ln))

return0；

/*忽略我们不理解的线*/

return0；

}

/*打开RadianceRGBE(或XYZE)图片和关联的深度缓冲器＊/

constchar*

TPopenPicture(InPicture*ip,constchar*pname,constchar*zname)

{

FILE*infp；

char*verr；

inti；

intdfd；

off_timgStart,imgEnd；

/*关闭先前的第一*/

TPclosePicture(ip)；

i＝strlen(pname)+(1-sizeof(ip->fname))；

i*＝(i>0)；

strcpy(ip->fname,pname+i)；

infp＝fopen(pname,"rb")；/*打开Radiance图片*/

if(infp＝＝NULL)

return"cannotopenRadiancepicture"；

ip->vw＝stdview；

ip->expval＝1.；

strcpy(ip->fmt,COLRFMT)；

if(getheader(infp,&TPheadLine,ip)<0){fclose(infp)；

return"errorinRadiancepictureformat"；

}

if(ip->vw.type！＝VT_PER){

fclose(infp)；

return"onlyperspectiveinputpicturessupported"；

}

if(ip->vw.vfore>FTINY){fclose(infp)；

return"pictureswithforeclippingplanesnotsupported"；

}

if((verr＝setview(&ip->vw))！＝NULL){

fclose(infp)；

returnverr；

}

if(！fgetsresolu(&ip->rs,infp)){

fclose(infp)；

return"badresolutionstringinRadiancepicture"；

}

ip->p2h＝ip->p2v＝.0；

imgStart＝ftello(infp)；

/*尝试将图片映射到存储器*/

if(fseeko(infp,0,SEEK_END)＝＝EOF){fclose(infp)；

return"cannotseekonRadiancepicture"；

}

imgEnd＝ftello(infp)；/*我们可以映射平坦图片文件＊/

if(imgEnd-imgStart＝＝sizeof(COLR)*ip->rs.xr*ip->rs.yr){

ip->pmap＝(uby8*)mmap(0,imgEnd,PROT_READ,

MAP_PRIVATEIMAP_FILE,fileno(infp),0)；

if(ip->pmap＝＝MAP_FAILED)

ip->pmap＝NULL；

else

ip->pimg＝(COLR*)(ip->pmap+imgStart)；

}

if(ip->pmap＝＝NULL){/*否则，装载到存储器中*/

constintns＝numscans(&ip->rs)；

constintsi＝scanlen(&ip->rs)；

inty；

ip->pmap＝mmap(0,sizeof(COLR)*ip->rs.xr*ip->rs.yr,

PROT_WRITEIPROT_READ,

MAP_PRIVATEIMAP_ANON,-1,0)；

if(ip->pmap＝＝MAP_FAILED){

ip->pmap＝NULL；

fclose(infp)；

return"outofmemoryinTPopenPicture()"；

}

ip->pimg＝(COLR*)ip->pmap；

fseeko(infp,imgStart,SEEK_SET)；

for(y＝0；y<ns；y++)

if(freadcolrs(TPcolrScan(ip,y),si,infp)<0){

fclose(infp)；

return"errorreadingRadiancepicture"；

}

}

fclose(infp)；

/*将深度缓冲器映射到存储器＊/

dfd＝open(zname,0_RDONLY)；

if(dfd<0)

return"cannotopendepthbufferfile"；

imgEnd＝lseek(dfd,0,SEEK_END)；

if(imgEnd！＝sizeof(float)*ip->rs.xr*ip->rs.yr){

close(dfd)；

return"unexpectedlengthfordepthbufferfile"；

}

ip->dimg＝(float*)mmap(0,imgEnd,PROT_READ,

MAP_PRIVATEIMAP_FILE,dfd,0)；

close(dfd)；

if(ip->dimg＝＝MAP_FAILED){

ip->dimg＝NULL；

return"failuremappingdepthbufferintomemory"；

}

ip->drng[0]＝/*得到极值*/

ip->drng[l]＝ip->dimg[0]；

for(i＝ip->rs.xr*ip->rs.yr；--i；)

if(ip->dimg[i]<ip->drng[0])

ip->drng[0]＝ip->dimg[i]；

elseif(ip->dimg[i]>ip->drng[1])

ip->drng[1]＝ip->dimg[i]；

returnNULL；/*全部良好*/

}

#defineDSCALE2846.10546/*(2^16-2)/log(1e6/1e-4)*/

#defineDOFFS-9.21034037/*log(1e-4)*/

/*将深度值编码到16比特(对数范围:1e-4到1e6)*/

int

TPencodeDepth(doubledpth)

{

if(dpth<＝le-4)

return1；

if(dpth>＝le6)

returnOxffff；

return(int)(DSCALE*(log(dpth)-DOFFS))+1；

}

/*解码16比特的深度值＊/

double

TPdecodeDepth(intdc)

{

returnexp((dc-l)*(l./DSCALE)+DOFFS)；

}

#undefDSCALE

#undefDOFFS

/*计算视图之间的距离度量(启发式的)*/

double

TPviewDistance(constVIEW*v1p,constVIEW*v2p)

{

doubled,d2sum；

FVECTvie,v2c；

if(v1p->type＝＝VT_PAR^v2p->type＝＝VT_PAR)

returnFHUGE；

d2sum＝(double)(v1p->type！＝v2p->type)；

if(v1p->vdist<1.5*v2p->vdist&&v2p->vdist<1.5*v1p->vdist){

VSUM(v1c,v1p->vp,v1p->vdir,v1p->vdist)；

VSUM(v2c,v2p->vp,v2p->vdir,v2p->vdist)；

d2sum+＝dist2(vlc,v2c)/(v1p->vdist*v2p->vdist)；

}else

d2sum+＝dist2(v1p->vp,v2p->vp)/(v1p->vdist*v2p->vdist)；

d2sum+＝dist2(v1p->hvec,v2p->hvec)/v1p->hn2；

d2sum+＝dist2(v1p->vvec,v2p->vvec)/v2p->vn2；

d＝v1p->hoff-v2p->hoff；

d2sum+＝d*d；

d＝v1p->voff-v2p->voff；

d2sum+＝d*d；

d＝v1p->vfore-v2p->vfore；

d2sum+＝d*d/(v1p->vdist*v2p->vdist)；

/*忽略裁切后平面*/

returnd2sum；

}

/*得到直到最接近给定视点的透镜图片的有序列表*/

int

TPpicNearest(int*parr,intlen,constVIEW*vp,constTapestryObj*tp)

{

intnc＝0；

double*vwdist；

doubled；

inti,j；

/*分配阵列*/

vwdist＝(double*)malloc(sizeof(double)*len)；

if(vwdist＝＝NULL)

return0；

/*插入排序*/

for(i＝tp->ninp；i-->0；){

d＝TPviewDistance(vp,&tp->inp[i].vw)；

if(d>＝FHUGE)

continue；

for(j＝nc；j--；){

if(d>＝vwdist[j])

break；

if(j<len-1){

vwdist[j+1]＝vwdist[j]；

parr[j+1]＝parr[j]；

}

}

nc+＝(nc<len)；

if(++j<nc){

parr[j]＝i；

vwdist[j]＝d；

}

}

free(vwdist)；

returnnc；

}

/*选择最接近打开图片的平均值的视图*/

constVIEW*

TPcentralView(constTapestryObj*tp)

{

intbest；

VIEWvavg；

inti；

vavg＝tp->inp[0].vw；

/*XXX我们假设其它参数没有改变＊/

for(i＝tp->ninp；--i；){

VADD(vavg.vp,vavg.vp,tp->inp[i].vw.vp)；

VADD(vavg.vup,vavg.vup,tp->inp[i].vw.vup)；

VADD(vavg.vdir,vavg.vdir,tp->inp[i].vw.vdir)；

}

vavg.vp[0]/＝(double)tp->ninp；

vavg.vp[l]/＝(double)tp->ninp；

vavg.vp[2]/＝(double)tp->ninp；

if(setview(&vavg)！＝NULL)

returnNULL；

vavg.vdist＝1.；/*实在没有影响我们*/

if(！TPpicNearest(&best,1,&vavg,tp))

returnNULL；

return&tp->inp[best].vw；

}

/*在视图之间映射图像位置*/

int

TPmapLocation(FVECTloc,constVIEW*vsrc,constVIEW*vdst)

{

FVECTpscene,pdir；

if(viewray(pscene,pdir,(VIEW*)vsrc,loc[0],loc[1])<-FTINY)

return0；

VSUM(pscene,pscene,pdir,loc[2])；

viewloc(loc,(VIEW*)vdst,pscene)；

return(loc[2]>.0)；

}

/*结合的织锦创建和呈现＊/

constchar*

TPrenderTapestry(constchar*pname,constchar*cname,

TapestryObj*tp,intxres,intyres)

{

constchar*err；

constVIEW*vctr；

inti；

/*检查我们具有某物*/

if(！TPpicReady(&tp->inp[0]))

return"nopicturesloaded"；

/*设定输出分辨率＊/

tp->trs.xr＝(xres>0)？xres:tp->inp[0].rs.xr；

tp->trs.yr＝(yres>0)？yres:tp->inp[0].rs.yr；

/*选择中心视图*/

if((vctr＝TPcentralView(tp))＝＝NULL)

return"cannotdeterminecentralview"；

tp->tvw＝*vctr；

/*将深度映射到默认视图中*/

if((err＝TPmapPictures(tp))！＝NULL)

returnerr；

/*寻找每个像素处的最佳视图*/

if((err＝TPchooseViews(tp))！＝NULL)

returnerr；

/*呈现以输出*/

if((err＝TPoutputTapestry(pname,cname,tp))！＝NULL)

returnerr；

/*释放临时缓冲器*/

free(tp->offs)；

tp->offs＝NULL；

for(i＝tp->ninp；i--；){

free(tp->inp[i].pref)；

tp->inp[i].pref＝NULL；

}

returnNULL；/*全部完成！*/

}

/*

*mktapestry2.c

*

*根据一组Radiance图片和z缓冲器

*创建织锦图像和3-D世界坐标缓冲器。

*

*用于映射图片(阶段1)的例程：

*在默认视图中的每个像素处，记录不同深度的列表

*由远到近(直到8)，并且标记哪些视图看到每个。

*

*由GregWard于2/28/11创建。

*版权2011DolbyLaboratories。保留所有权利。

*

*/

#include<stdio.h>

#include"mktapestry.h"

#ifndefDEPS

#defineDEPS5/*用于匹配的深度epsilon*/

#endif

/*将深度缓冲器加到我们的集合*/

staticint

TPaddDepthBuf(TapestryObj*tp)

{

intdi；

for(di＝0；tp->edbuf[di]！＝NULL；di++)

if(di>＝7)

return0；

tp->edbuf[di]＝(uint16*)calloc(tp->trs.xr*tp->trs.yr,sizeof(uint16))；

return(tp->edbuf[di]！＝NULL)？1:-1；

}

/*将深度值插入到我们的缓冲器和调整标记*/

staticint

TPinsertDepth(intpos[3],TapestryObj*tp,intii)

{

InPicture*ip＝&tp->inp[ii]；

uint16*dptr,*dptr2；

intdi,di2,i；

/*确保分配标记*/

if(ip->dfli＝＝NULL){

ip->dfli＝(uby8*)calloc(tp->trs.xr*tp->trs.yr,sizeof(uby8))；

if(ip->dfli＝＝NULL)

return-1；

}

/*寻找/插入深度*/

for(di＝0；di<8；di++){

if(tp->edbuf[di]＝＝NULL&&TPaddDepthBuf(tp)<＝0)

return-1；

dptr＝TPedScan(tp,di,pos[1])+pos[0]；

/*这里还没有什么？*/

if(！*dptr){

*dptr＝pos[2]；

TPdfScan(tp,ii,pos[1])[pos[0]]|＝1<<di；

return1；

}

/*关闭足以调用匹配？*/

if((*dptr<＝pos[2]+DEPS)&(pos[2]<＝*dptr+DEPS)){

TPdfScan(tp,ii,pos[1])[pos[0]]|＝1<<di；

return1；

}

/*还没有到达深度？*/

if(*dptr<pos[2])

continue；

/*或需要插入*/

for(di2＝di+1；di2<8；di2++){

if(tp->edbuf[di2]＝＝NULL&&TPaddDepthBuf(tp)<＝0)

return-1；

dptr2＝TPedScan(tp,di2,pos[1])+pos[0]；

if(！*dptr2)

break；

}

for(di2-＝(di2>＝8)；di2>di；di2--){

dptr＝TPedScan(tp,di2-1,pos[1])+pos[0]；

*dptr2＝*dptr；

dptr2＝dptr；

}

/*更新图片标记*/

for(i＝tp->ninp；i--；){

uby8*dfp；

intfmask；

if(tp->inp[i].dfli＝＝NULL)

continue；

fmask＝(1<<di)-1；

dfp＝TPdfScan(tp,i,pos[1])+pos[0]；

*dfp＝(*dfp&～fmask)<<1|(*dfp&fmask)；

}

/*最终，更新这个深度*/

*dptr＝pos[2]；

TPdfScan(tp,ii,pos[1])[pos[0]]|＝1<<di；

return1；

}

/*深度复杂度＝＝8--忽略*/

return0；

}

/*将来自指示图像的像素位置映射到默认视图*/

staticint

TPmapPosition(intpos[3],TapestryObj*tp,intii)

{

InPicture*ip＝&tp->inp[ii]；

FVECTimp；

pix21oc(imp,&ip->rs,pos[0],pos[1])；

imp[2]＝TPdpthScan(ip,pos[1])[pos[0]]；

if(！TPmapLocation(imp,&ip->vw,&tp->tvw))

return0；

if((imp[0]<＝FTINY)|(imp[0]>＝1.-FTINY)||

(imp[1]<＝FTINY)|(imp[1]>＝1.-FTINY))

return0；

loc2pix(pos,&tp->trs,imp[0],imp[1])；

pos[2]＝TPencodeDepth(imp[2])；

return1；

}

/*将距给定图像的距离映射到我们的经编码的多深度缓冲器中*/

staticconstchar*

TPmapDepths(TapestryObj*tp,intii)

{

InPicture*ip＝&tp->inp[ii]；

constintsameView＝(！memcmp(&tp->trs,&ip->rs,sizeof(RESOLU))

&&TPviewDistance(&tp->tvw,&ip->vw)<＝FTINY)；

intpos[3]；

intx,y；

for(y＝numscans(&ip->rs)；y--；)

for(x＝scanlen(&ip->rs)；x--；){

pos[0]＝x；pos[1]＝y；

if(sameView)

pos[2]＝TPencodeDepth(TPdpthScan(ip,y)[x])；

elseif(！TPmapPosition(pos,tp,ii))

continue；

if(TPinsertDepth(pos,tp,ii)<0)

return"outofdepthmemoryinTPmapDepth()"；

}

returnNULL；

}

/*排序输入图片使得最接近的图片首先来*/

staticint

TPsortInput(TapestryObj*tp)

{

int*inear；

InPicture*pnear；

inti,j,n；

if(tp->ninp<＝1)

return1；

inear＝(int*)malloc(sizeof(int)*tp->ninp)；

if(inear＝＝NULL)

return0；

n＝TPpicNearest(inear,tp->ninp,&tp->tvw,tp)；

if(！n)

return0；

pnear＝(InPicture*)malloc(sizeof(InPicture)*n)；

for(i＝n；i--；){

pnear[i]＝tp->inp[inear[i]]；

tp->inp[inear[i]].vw.type＝0；

}

free(inear)；

for(i＝tp->ninp；i-->n；){

while(tp->inp[i].vw.type)

i--；

if(i<n)

break；

for(j＝i；！tp->inp[-j].vw.type；)；

tp->inp[i]＝tp->inp[j]；

tp->inp[j].vw.type＝0；

}

for(i＝n；i--；)

tp->inp[i]＝pnear[i]；

free(pnear)；

returnn；

}

#defineFEQ(a,b)((a)<＝1.001*(b)&&(b)<＝1.001*(a))

/*将我们的输入视图映射到默认视图中，记录多个深度*/

constchar*

TPmapPictures(TapestryObj*tp)

{

constchar*err；

inti；

/*设定我们的视图*/

if((err＝setview(&tp->tvw))！＝NULL)

returnerr；

normaspect(viewaspect(&tp->tvw),&tp->pixaspect,

&tp->trs.xr,&tp->trs.yr)；

/*检查输入图片*/

for(i＝0；i<tp->ninp；i++){

if(！TPpicReady(&tp->inp[i]))

return"someinputpicturesnotready"；

if(DOT(tp->inp[i].vw.vup,tp->tvw.vup)<l.-FTINY)

return"inputpictureupvectorsmustmatchoutput"；

tp->inp[i].p2h＝sqrt(tp->inp[i].vw.hn2/tp->tvw.hn2)；

tp->inp[i].p2v＝sqrt(tp->inp[i].vw.vn2/tp->tvw.vn2)；

if(！i)

continue；

if(！FEQ(tp->inp[i].expval,tp->inp[0].expval))

return"inputpictureexposuresdonotmatch"；

if(strcmp(tp->inp[i].fmt,tp->inp[0].fmt))

return"inputformatsdonotmatch"；

}

/*排序输入图片*/

TPsortInput(tp)；

/*映射我们的深度值*/

for(i＝0；i<tp->ninp；i++)

if((err＝TPmapDepths(tp,i))！＝NULL)

returnerr；

returnNULL；/*全部良好*/

}

#undefFEQ

/*

*mktapestry3.c

*

*根据一组Radiance图片和z缓冲器

*创建织锦图像和3-D世界坐标缓冲器。

*

*收集目标图像中的优选视图统计值(阶段2)：

*在每个默认视图输出像素处，

*为看到我们的多深度缓冲器中的最多/最近的点的输入图片投票。

*沿着将最近的3-D位置与默认视图中的最远处连接的线段

*记录对于这个视图的偏好。

*也记录前景像素对于输出像素位置的2-D偏移，

*因此我们知道哪里

*锚定输出图像中的所选视图。

*

*由GregWard于2/28/11创建。

*版权2011DolbyLaboratories。保留所有权利。

*

*/

#include<stdio.h>

#include<string.h>

#include"mktapestry.h"

#ifndefGAUSS_BLUR

#defineGAUSS_BLUR8/*针对结果平滑化半径＊/

#endif

/*返回与给定一组深度标记关联的值*/

staticint

TPdepthFlagVal(intfl)

{

staticuby8flagVal[256]；

inti；

/*第一轮初始化*/

for(i＝flagVal[255]？0:256；i--；){

intflv,vb；

/*

*基于基逆的点尺度意味着

*正面层值得多于所有更深层结合，

*第二层照样...

*/

flagVal[i]＝0；

vb＝256；

for(flv＝i；flv；flv>>＝1)

flagVal[i]+＝(flv&l)*(vb>>＝1)；

}

returnflagVal[fl]；

}

/*针对目标图像中的这个位置拾取最佳视图*/

staticint

TPpicBest(TapestryObj*tp,intx,inty)

{

Inti,ibest,vbest,flv；

/*寻找这个像素处的最佳视图*/

ibest＝-1；

vbest＝0；

for(i＝0；i<tp->ninp；i++){

flv＝TPdepthFlagVal(TPdfScan(tp,i,y)[x])；

if(flv>vbest){

ibest＝i；

vbest＝flv；

}

}

returnibest；

}

/*投票目标中的这个点处的我们的偏好*/

staticvoid

TPdrawPoint(TapestryObj*tp,intii,intx,inty,doublewt,doubleox,doubleoy)

{

float*offs＝TPoffsum(tp,x,y)；

/*针对偏移投票*/

offs[0]+＝wt*ox；

offs[1]+＝wt*oy；

/*针对优选视图投票*/

TPprScan(tp,ii,y)[x]+＝wt；

}

/*绘制具有优选视图和偏移的投票线*/

staticvoid

TPdrawPref(TapestryObj*tp,intii,intx,inty,intdx,intdy,intox,intoy)

{

constintxmax＝scanlen(&tp->trs)-1；

constintymax＝numscans(&tp->trs)-1；

longrun2＝0,rise2＝0；

doubled,r；

intxstep＝l,ystep＝1,n；

/*检查特殊情况*/

if(！dx&！dy){

TPdrawPoint(tp,ii,x,y,TPdepthFlagVal(1),ox,oy)；

return；

}

xstep-＝2*(dx<0)；

ystep-＝2*(dy<0)；

#if0

/*#ifdefGAUSS_BLUR

/*绘制后端以补偿*/

d＝2.*GAUSS_BLUR/sqrt(dx*dx+dy*dy)；

dx+＝(int)(d*dx+.5*xstep)；

dy+＝(int)(d*dy+.5*ystep)；

#endif

/*裁剪线到图像界限*/

if(x+dx<0){

dy＝dy*-x/dx；

dx＝-x；

}elseif(x+dx>xmax){

dy＝dy*(xmax-x)/dx；

dx＝xmax-x；

}

if(y+dy<0){

dx＝dx*-y/dy；

dy＝-y；

}elseif(y+dy>ymax){

dx＝dx*(ymax-y)/dy；

dy＝ymax-y；

}

/*结束绘制配置*/

dx*＝xstep；

dy*＝ystep；

n＝(dx>dy)？dx:dy；

d＝TPdepthFlagVal(TPdfScan(tp,ii,y)[x])；

/*XXXr设定是高度启发的*/

r＝.0007*sqrt((double)tp->trs.xr*tp->trs.yr)；

/*绘制我们的线*/

if(dx>＝dy)

while(n>＝0)

if(run2>＝rise2){

TPdrawPoint(tp,ii,x,y,

d*(r+n)/(50*r+n),ox,oy)；

n--；

x+＝xstep；

rise2+＝dy；

}else{

y+＝ystep；

run2+＝dx；

}

Elsewhile(n>＝0)

if(rise2>＝run2){

TPdrawPoint(tp,ii,x,y,d*(r+n)/(50.*r+n),ox,oy)；

n--；

y+＝ystep；

run2+＝dx；

}else{x+＝xstep；

rise2+＝dy；

}

}

/*针对我们的输出中的给定点处的给定视图投票*/

staticint

TPvoteView(TapestryObj*tp,intii,intx,inty)

{

InPicture*ip＝&tp->inp[ii]；

FVECTloc；

intfl,di；

intpos[2],posl[2]；

/*计算正面像素翻译*/

pix21oc(loc,&tp->trs,x,y)；

loc[2]＝TPdecodeDepth(TPedScan(tp,0,y)[x])；

if(！TPmapLocation(loc,&tp->tvw,&ip->vw))

return0；

loc2pix(pos,&tp->trs,

(loc[0]-.5+ip->vw.hoff)*ip->p2h+.5-tp->tvw.hoff,

(loc[1]-.5+ip->vw.voff)*ip->p2v+.5-tp->tvw.voff)；

/*给出最远深度的位置*/

fl＝TPdfScan(tp,ii,y)[x]；

for(di＝0；fl&～1；fl>>＝1)

di++；

if(di){pix2loc(loc,&tp->trs,x,y)；

loc[2]＝TPdecodeDepth(TPedScan(tp,di,y)[x])；

if(！TPmapLocation(loc,&tp->tvw,&ip->vw))return0；

loc2pix(pos1,&tp->trs,(loc[0]-.5+ip->vw.hoff)*ip->p2h+.5-tp->tvw.hoff,

(loc[1]-.5+ip-

>vw.voff)*ip->p2v+.5-tp->tvw.voff)；

}else{pos1[0]＝pos[0]；

pos1[1]＝pos[1]；

}

/*绘制我们的投票线*/

TPdrawPref(tp,ii,x,y,pos1[0]-pos[0],pos1[1]-pos[1],

pos[0]-x,pos[1]-y)；

return1；

}

#ifdefGAUSS_BLUR

#definerbscan(yo)(rollingBuffer+(((yo)+bufRad)％bufHeight)*xres)

/*平滑化给定浮点图像(原地可分隔的高斯滤波器)*/

staticvoid

TPblurImage(float*img,constintxres,constintyres,

constintxstride,constintystride)

{

constintbufRad＝GAUSS_BLUR*3.2+.5；

constintbufHeight＝2*bufRad+1；

float*rollingBuffer,*gaussTab；

float*dp,*bp；

doublesum；

intx,y,i；

/*显著度检查*/

if((xres<＝bufRad)|(yres<＝bufRad))

return；

/*分配滚动更新缓冲器*/

rollingBuffer＝(float*)malloc(sizeof(float)*(xres+l)*bufHeight)；

if(rollingBuffer＝＝NULL)

return；

/*设立高斯权重表*/

gaussTab＝rollingBuffer+xres*bufHeight+bufRad；

sum＝.0；

gaussTab[0]＝1.f；

for(i＝1；i<＝bufRad；i++)

sum+＝gaussTab[-i]＝gaussTab[i]＝

exp(-i*i*(1./GAUSS_BLUR/GAUSS_BLUR))；

for(i＝-bufRad；i<＝bufRad；i++)

gaussTab[i]/＝sum；

/*过滤图像*/

for(y＝-bufRad；y<yres；y++){

/*更新滚动更新过滤缓冲器*/

if(y+bufRad>＝yres){

memcpy(rbscan(y+bufRad),rbscan(y-l),sizeof(float)*xres)；

}else{

dp＝img+(y+bufRad)*ystride；

memset(bp＝rbscan(y+bufRad),0,sizeof(float)*xres)；

for(x＝0；x<xres；x++,bp++)

for(i＝-bufRad；i<＝bufRad；i++){

intxi＝x+bufRad+i；

if(xi<0)xi＝0；

elseif(xi>＝xres)xi＝xres-1；

*bp+＝dp[xi*xstride]*gaussTab[i]；

}

}

if(y<0)

continue；

if(！y)/*结束顶部扫描初始化*/

for(i＝-bufRad；i<0；i++)

memcpy(rbscan(i),rbscan(O),sizeof(float)*xres)；

dp＝img+y*ystride；/*updatefinalimage*/

for(x＝xres；x—；dp+＝xstride)

*dp＝.0f；

for(i＝-bufRad；i<＝bufRad；i++){

bp＝rbscan(y+i)；

dp＝img+y*ystride；

for(x＝xres；x--；dp+＝xstride)

*dp+＝*bp++*gaussTab[i]；

}

}

/*清除*/

free(rollingBuffer)；

}

#undefrbscan

#endif

/*确定织锦中的每个像素处的最佳视图*/

constchar*

TPchooseViews(TapestryObj*tp)

{

constintxres＝scanlen(&tp->trs)；

constintyres＝numscans(&tp->trs)；

inti,x,y；

/*确保我们具有我们所需要的*/

if(tp->edbuf[0]＝＝NULL)

return"missingdepthbufferinTPchooseViews()"；

for(i＝0；i<tp->ninp；i++){

if(tp->inp[i].dfli＝＝NULL)

return"missingdepthflagsinTPchooseViews()"；

if(tp->inp[i].pref＝＝NULL){

tp->inp[i].pref＝(float*)malloc(sizeof(float)*

tp->trs.xr*tp->trs.yr)；

if(tp->inp[i].pref＝＝NULL)

return"cannotallocateviewpreferencebuffer"；

}

memset(tp->inp[i].pref,0,sizeof(float)*tp->trs.xr*tp->trs.yr)；

}

if(tp->offs＝＝NULL){

tp->offs＝(float(*)[2])malloc(sizeof(float)*2*

tp->trs.xr*tp->trs.yr)；

if(tp->offs＝＝NULL)

return"cannotallocateoffsetarray"；

}

memset(tp->offs,0,sizeof(float)*2*tp->trs.xr*tp->trs.yr)；

/*针对每个像素处的最好视图投票*/

for(y＝yres；y--；)

for(x＝xres；x--；)

if((i＝TPpicBest(tp,x,y))>＝0)

TPvoteView(tp,i,x,y)；

/*释放我们不再需要的缓冲器*/

for(i＝0；i<8&&tp->edbuf[i]！＝NULL；i++){

free(tp->edbuf[i])；tp->edbuf[i]＝NULL；

}

for(i＝0；i<tp->ninp；i++){

free(tp->inp[i].dfli)；tp->inp[i].dfli＝NULL；

}

#ifdefGAUSS_BLUR/*平滑化结果*/

TPblurImage(&tp->offs[0][0],xres,yres,2,2*xres)；

TPblurImage(&tp->offs[0][l],xres,yres,2,2*xres)；

for(i＝0；i<tp->ninp；i++)

TPblurImage(tp->inp[i].pref,xres,yres,1,xres)；

#endif

returnNULL；

}

/*

*mktapestry4.c

*

*根据一组Radiance图片和z缓冲器

*创建织锦图像和3-D世界坐标缓冲器。

*

*呈现输出图像(阶段3)：

*在每个默认视图输出像素处，根据阶段2中收集的统计值

*计算平均偏移和优选视图。

*通过跟踪光线到被处理为高度场的图像中，

*根据这个像素处的最流行视图，

*呈现实际像素颜色和3-D坐标。

*

*由GregWard于2/28/11创建。

*版权2011DolbyLaboratories。保留所有权利。

*

*/

#include<stdio.h>

#include"mktapestry.h"

#include"platform.h"

/*Findexitingintersectionwithsphere*/

staticdouble

TPsphereExit(constFVECTrorg,constFVECTrdir,constFVECTctr,doublerad)

{

FVECTOC；

doubleroot[2]；

intnroots；

VSUB(OC,rorg,ctr)；

nroots＝quadratic(root,1.,2*DOT(rdir,OC),DOT(OC,OC)-rad*rad)；

if(！nroots)

return.0；

returnroot[nroots-1]；

}

/*跟踪光线和与作为高度场的图片相交*/

staticint

TPhitPicture(COLRpc,FVECTrpos,constFVECTrdir,InPicture*ip)

{

doubleD_h,D_v,OE_h,OE_v,D_L,OE_L,OE_D；

uby8*clr；

FVECTOE；

inthdom；

intnsteps；

doublevlim[2],hlim[2],tlim[2]；

doubleh,v,t,d,hstep,vstep；

intinter[2]；

/*预计算环常数*/

D_L＝DOT(rdir,ip->vw.vdir)；

if(D_L<＝FTINY)

return0；

/*不会工作*/

D_h＝DOT(rdir,ip->vw.hvec)/ip->vw.hn2；

D_v＝DOT(rdir,ip->vw.vvec)/ip->vw.vn2；

/*前进到第一可能深度*/

t＝.9*TPsphereExit(rpos,rdir,ip->vw.vp,ip->drng[0])；

if(t>FTINY)

VSUM(rpos,rpos,rdir,t)；

/*计算其它常数*/

VSUB(OE,rpos,ip->vw.vp)；

OE_L＝DOT(OE,ip->vw.vdir)；

if(OE_L<＝FTINY){/*在视点前面推进开始*/

t＝1e-3-OE_L/D_L；

VSUM(rpos,rpos,rdir,t)；

VSUB(OE,rpos,ip->vw.vp)；

OE_L＝DOT(OE,ip->vw.vdir)；

}

OE_D＝DOT(OE,rdir)；/*沿着视线(相同视图)？*/

if(OE_D*OE_D>＝0.999995*DOT(OE,OE)){

FVECTvpos；

viewloc(vpos,(VIEW*)&ip->vw,rpos)；

if((vpos[0]<＝FTINY)|(vpos[0]>＝1.-FTINY))

return0；

if((vpos[l]<＝FTINY)|(vpos[l]>＝1.-FTINY))

return0；

loc2pix(inter,(RESOLU*)&ip->rs,vpos[0],vpos[1])；

d＝TPdpthScan(ip,inter[1])[inter[0]]；

VSUM(rpos,ip->vw.vp,rdir,d)；

clr＝TPcolrScan(ip,inter[1])[inter[0]]；

copycolr(pc,clr)；

return1；

}

OE_h＝DOT(OE,ip->vw.hvec)/ip->vw.hn2；

OE_v＝DOT(OE,ip->vw.vvec)/ip->vw.vn2；

/*寻找平截头体入口和出口*/

hlim[0]＝(OE_h-(ip->vw.hoff+.5)*OE_L)/((ip->vw.hoff+.5)*D_L-D_h)；

if(hlim[0]*D_L<＝-OE_L)hlim[0]＝FHUGE；

hlim[1]＝(OE_h-(ip->vw.hoff-.5)*OE_L)/((ip->vw.hoff-.5)*D_L-D_h)；

if(hlim[1]*D_L<＝-OE_L)hlim[1]＝FHUGE；

if(hlim[0]>hlim[1]){t＝hlim[0]；hlim[0]＝hlim[1]；hlim[1]＝t；}

if(hlim[0]>＝FHUGE)

return0；

/*光线经过平截头体*/

vlim[0]＝(OE_v-(ip->vw.voff+.5)*OE_L)/((ip->vw.voff+.5)*D_L-D_v)；

if(vlim[0]*D_L<＝-OE_L)vlim[0]＝FHUGE；

vlim[1]＝(OE_v-(ip->vw.voff-.5)*OE_L)/((ip->vw.voff-.5)*D_L-D_v)；

if(vlim[1]*D_L<＝-OE_L)vlim[1]＝FHUGE；

if(vlim[0]>vlim[1]){t＝vlim[0]；vlim[0]＝vlim[1]；vlim[1]＝t；}

if(vlim[0]>＝FHUGE)

return0；

/*光线经过平截头体*/

tlim[0]＝(hlim[0]>vlim[0])？hlim[0]:vlim[0]；

if(tlim[0]<.0)tlim[0]＝.0；

tlim[1]＝(hlim[1]<vlim[1])？hlim[1]:vlim[1]；

/*检查最大图片深度*/

t＝1.1*TPsphereExit(rpos,rdir,ip->vw.vp,ip->drng[1])；

if(t<tlim[1])

tlim[1]＝t；

if(tlim[1]<＝tlim[0])

return0；

/*现在我们知道我们的极限*/

hlim[0]＝(tlim[0]*D_h+OE_h)/(tlim[0]*D_L+OE_L)；

hlim[1]＝(tlim[1]*D_h+OE_h)/(tlim[1]*D_L+OE_L)；

vlim[0]＝(tlim[0]*D_v+OE_v)/(tlim[0]*D_L+OE_L)；

vlim[1]＝(tlim[1]*D_v+OE_v)/(tlim[1]*D_L+OE_L)；

hstep＝ip->rs.xr*fabs(hlim[1]-hlim[0])；

vstep＝ip->rs.yr*fabs(vlim[1]-vlim[0])；

hdom＝(hstep>vstep)；

nsteps＝(hdom？hstep:vstep)+.999；

/*走过作为高度场的我们的图片*/

hstep＝(hlim[1]-hlim[0])/nsteps；

vstep＝(vlim[1]-vlim[0])/nsteps；

h＝hlim[0]+.5*hstep；

v＝vlim[0]+.5*vstep；

while(nsteps--){/*检查每个步骤处的相交*/

doubled2；

if(nsteps)t＝hdom？(OE_h-h*OE_L)/(h*D_L-D_h):(OE_v-v*OE_L)/(v*D_L-D_v)；

elset＝tlim[1]；/*确保我们到达端点*/d2＝(t+OE_D)/(D_L+h*D_h*ip->vw.hn2+v*D_v*ip->vw.vn2)；

d2*＝d2*(1。+h*h*ip->vw.hn2+v*v*ip->vw.vn2)；

/*比较深度*/loc2pix(inter,(RESOLU*)&ip->rs,h+.5-ip->vw.hoff,v+.5-ip->vw.voff)；

d＝TPdpthScan(ip,inter[1])[inter[0]]；

if(d*d<＝d2){FVECTvrd；

pix21oc(vrd,&ip->rs,inter[0],inter[1])；

if(viewray(rpos,vrd,&ip->vw,vrd[0],vrd[1])<-FTINY)return0；

VSUM(rpos,rpos,vrd,d)；

/*先前版本:VSUM(rpos,rpos,rdir,t)；*/clr＝TPcolrScan(ip,inter[1])[inter[0]]；

copycolr(pc,clr)；

return1；

/*得到它了！*/

}

h+＝hstep；v+＝vstep；

}

return0；/*没有击中任何东西*/

}

/*对于这个像素处的优选视图计算前颜色和3-D坐标*/

staticint

TPtapPixel(COLRpc,floatpt[3],TapestryObj*tp,intx,inty)

{

staticCOLORipcolor[36]＝{

0,1.492,0,

2.2627,0.568644,0.298338,

3.60996,0.0447306,0.206002,

0.499993,1.23912,0.573725,

1.18038,0.908543,1.2073,

2.26022,0.392666,2.12237,

0.87003,0.845226,3.12524,

1.0278,1.01936,0.6871,

0.390957,1.31389,0.247557,

0.98227,0.868362,2.42917,

0.515437,0.89141,4.09484,

1.34064,0.649471,3.22438,

1.70306,0.795677,0.239781,

1.1597,0.92773,1.09386,

2.19252,0.592737,0.336119,

0.194031,1.28974,1.29931,

0.196925,1.40148,0.135696,

0.0079644,1.403,0.890442,

1.27808,0.76974,2.23975,

0.542429,1.24974,0.291194,

0.294654,1.11767,2.66268,

0.73491,1.17444,0.282685,

0.93403,1.04359,0.819692,

0.125985,1.42046,0.229271,

0.184016,1.32542,0.972381,

0.728155,1.11374,0.935897,

1.27537,0.868586,1.23191,

0.917956,1.08088,0.500816,

0.254634,1.19385,2.04063,

0.128916,1.42746,0.145216,

0.934682,1.09907,0.245137,

1.15713,0.745004,2.9878,

1.11901,1.02415,0.265871,

1.09725,0.954785,1.0696,

0.807408,1.13229,0.421597,

0.144215,1.41542,0.206926,

}；

COLORpcolor；

staticCOLRredcolr＝{255,0,0,COLXS}；

VIEWpvw＝tp->tvw；

float*offs；

doublenf；

RREALvloc[2]；

FVECTrpos,rdir；

inttpos[2]；

inti,ibest；

floatsc,sbest,tally；

/*平均化视图原点和方向*/

pvw.vp[0]＝pvw.vp[l]＝pvw.vp[2]＝.0；

pvw.vdir[0]＝pvw.vdir[l]＝pvw.vdir[2]＝.0；

ibest＝-1；sbest＝.0；

tally＝.0；

for(i＝0；i<tp->ninp；i++){

if((sc＝TPprScan(tp,i,y)[x])<＝FTINY)

continue；

if(sc>sbest){

ibest＝i；

sbest＝sc；

}

VSUM(pvw.vp,pvw.vp,tp->inp[i].vw.vp,sc)；

VSUM(pvw.vdir,pvw.vdir,tp->inp[i].vw.vdir,sc)；

tally+＝sc；

}

if(tally<＝FTINY)/*这里没有任何东西？！*/

return-1；

#if0

copycolor(pcolor,ipcolor[ibest％36])；

nf＝(y&l)？tally:sbest；

scalecolor(pcolor,nf)；

setcolr(pc,pcolor[RED],pcolor[GRN],pcolor[BLU])；

returnibest；

#endifnf＝1./tally；

pvw.vp[0]*＝nf；pvw.vp[l]*＝nf；pvw.vp[2]*＝nf；

if(setview(&pvw)！＝NULL)

return-1；

/*XXXurp！*/

pvw.vdist＝1.；

offs＝TPoffsum(tp,x,y)；

/*我们哪里在优选视图中？*/

pix2loc(vloc,&tp->trs,(int)(x+offs[0]*nf+.5),

(int)(y+offs[1]*nf+.5))；

/*相交最近视图*/

if(viewray(rpos,rdir,&pvw,vloc[0],vloc[1])<-FTINY)

return-1；

if(！TPhitPicture(pc,rpos,rdir,&tp->inp[ibest]))

return-1；

VCOPY(pt,rpos)；

/*复制相交点*/

returnibest；

}

/*输出完整的织锦和3-D坐标图像*/

constchar*

TPoutputTapestry(constchar*pname,constchar*cname,TapestryObj*tp)

{

constintsl＝scanlen(&tp->trs)；

constintns＝numscans(&tp->trs)；

intnbad＝0；

intgotFirst；

FILE*pfp,*cfp；

constchar*err；

COLRpcolr,apcolr；

floatworld3d[3],aworld3d[3]；

inti,x,y；

/*确保我们具有我们需要的*/

if(tp->offs＝＝NULL)

return"missingoffsetsinTPoutputTapestry()"；

for(i＝0；i<tp->ninp；i++)

if(tp->inp[i].pref＝＝NULL)

return"missingpreferredviewsinTPoutputTapestry()"；

/*打开输出图像*/

if(pname＝＝NULL||！*pname){

pfp＝stdout；

SET_FILE_BINARY(pfp)；

}elseif((pfp＝fopen(pname,"wb"))＝＝NULL)

return"cannotopentapestrypictureforoutput"；

if(cname＝＝NULL||！*cname)

cfp＝NULL；

elseif((cfp＝fopen(cname,"wb"))＝＝NULL)

return"cannotopentapestrycoordinatesforoutput"；

/*写图片报头*/

newheader("RADIANCE",pfp)；

fputs("Tapestrygeneratedfrom",pfp)；

for(i＝0；i<tp->ninp；i++){

fputs("'",pfp)；

fputs(tp->inp[i].fname,pfp)；

fputc('\",pfp)；

}

fputc('\n',pfp)；

fputnow(pfp)；

fputs(VIEWSTR,pfp)；

fprintview(&tp->tvw,pfp)；

fputc('\n',pfp)；

fputexpos(tp->inp[0].expval,pfp)；

if((tp->pixaspect<0.98)|(tp->pixaspect>1.02))

fputaspect(tp->pixaspect,pfp)；

fputformat(tp->inp[0].fmt,pfp)；

fputc('\n',pfp)；

fputsresolu(&tp->trs,pfp)；

/*输出每个像素*/

memset(apcolr,0,sizeof(apcolr))；

memset(aworld3d,0,sizeof(aworld3d))；

for(y＝0；y<ns；y++){

memcpy(pcolr,apcolr,sizeof(pcolr))；

memcpy(world3d,aworld3d,sizeof(world3d))；

gotFirst＝0；

for(x＝0；x<sl；x++){

if(TPtapPixel(pcolr,world3d,tp,x,y)<0){

++nbad；

/*

memset(pcolr,0,sizeof(pcolr))；

memset(world3d,0,sizeof(world3d))；

*/

}elseif(！gotFirst){

memcpy(apcolr,pcolr,sizeof(apcolr))；

memcpy(aworld3d,world3d,sizeof(aworld3d))；

gotFirst＝1；

}

fwrite(pcolr,sizeof(pcolr),1,pfp)；

if(cfp！＝NULL)

fwrite(world3d,sizeof(world3d),1,cfp)；

}

}

/*清除*/

if((pfp＝＝stdout？fflush(pfp):fclose(pfp))＝＝EOF)

return"errorwritingtapestrypicture"；

if(cfp！＝NULL&&fclose(cfp)＝＝EOF)

return"errorwritingtapestrycoordinates"；

/*XXX临时坏像素报告*/

if(nbad)

fprintf(stderr,"％.3f％％missingoutputpixels\n",nbad*100./(tp->trs.xr*tp->trs.yr))；

returnNULL；

}

Claims (25)

1.一种用于根据织锦图像产生场景的至少一个视图的方法，该至少一个视图中的每一个与场景的一个期望视点关联，所述方法包括如下步骤：

提供织锦图像；其中该织锦图像包括像素的2维阵列，该像素的2维阵列包括来自与场景关联的多个视图的信息；

提供与织锦图像关联的坐标图；其中与织锦图像关联的坐标图包括与织锦图像的像素关联的位置数据；其中与织锦图像的像素关联的位置数据包括用于织锦图像中的每个像素的深度数据；以及其中与织锦图像的像素关联的位置数据还包括用于织锦图像中的每个像素的水平视差数据和/或垂直视差数据；

基于该织锦图像和该坐标图来推导场景的一个或更多个视图。

2.根据权利要求1所述的方法，还包括：

提供场景的参考图像，每个参考图像与一个期望视点关联；以及

产生一个或更多个校正层，每个校正层与一个期望视点关联，其中基于与特定期望视点关联的参考图像和与相同的特定期望视点关联的推导出的视图来产生与该特定期望视点关联的校正层，

其中还基于该一个或更多个校正层来产生所述至少一个视图。

3.根据权利要求2所述的方法，其中一个或更多个校正层中的每一个基于在与特定期望视点关联的参考图像和与相同的特定期望视点关联的推导出的视图之间的差别。

4.根据权利要求3所述的方法，其中该差别包括从与相同的特定期望视点关联的推导出的视图中的每个像素中减去与特定期望视点关联的参考图像中的对应像素。

5.根据权利要求2所述的方法，其中推导的步骤包括对于该一个或更多个视图中的每个视图为来自该一个或更多个视图的视图添加来自一个或更多个校正层中的校正层，其中该视图和该校正层与相同的期望视点关联。

6.根据权利要求1所述的方法，其中推导的步骤包括基于织锦图像和坐标图执行纹理区域填充。

7.根据权利要求1所述的方法，其中提供织锦图像的步骤包括：

从场景的多个视点拍摄场景的图片；以及

处理所拍摄的图片以便产生织锦图像。

8.根据权利要求1所述的方法，其中提供织锦图像的步骤包括：

对于场景的多个视点使用计算机产生场景的图片；以及

处理计算机产生的图片以便产生织锦图像。

9.根据权利要求7所述的方法，其中处理织锦图像的步骤包括：

从场景的多个视图中选择视图；以及

执行基于所选的视图的结合以便产生织锦图像。

10.根据权利要求1所述的方法，其中提供织锦图像的步骤包括：

执行场景的分析以便获得与场景关联的多个特征；

把多个特征中的每个特征从最重要到最不重要按优先次序排列；以及

产生织锦图像使得与更低重要性的特征相比更高分辨率被分配给更高重要性的特征。

11.根据权利要求10所述的方法，其中执行分析的步骤基于重要性的人工分配、频率分析和显著度分析中的一个或更多个。

12.根据权利要求1所述的方法，还包括产生照相机格子，其中该照相机格子包括来自织锦图像的场景的至少一个图像中的每个图像的识别信息。

13.根据权利要求12所述的方法，其中特定图像的识别信息包括特定图像的视图位置、视图角、视图方向、取向以及水平和垂直尺寸中的至少一个。

14.一种适于接收场景的多个输入视图的编码系统，包括：

织锦产生器，适于基于该多个输入视图产生织锦图像和坐标图；其中该织锦图像包括像素的2维阵列，该像素的2维阵列包括来自场景的多个输入视图的信息；其中坐标图包括与织锦图像的像素关联的位置数据；其中与织锦图像的像素关联的位置数据包括用于织锦图像中的每个像素的深度数据；以及其中与织锦图像的像素关联的位置数据还包括用于织锦图像中的每个像素的水平视差数据和/或垂直视差数据；以及

编码器，适于将织锦图像和坐标图编码成比特流。

15.根据权利要求14所述的编码系统，还包括：

视图产生单元，适于基于该织锦图像和该坐标图来推导场景的一个或更多个视图；以及

与视图产生单元耦接的减法器，适于产生在一个或更多个推导出的视图和一个或更多个输入视图之间的差别，每个差别是在特定视点的推导出的视图和相同的特定视点的输入视图之间的差别，因此产生一个或更多个校正层，

其中编码器适于将织锦图像、坐标图和一个或更多个校正层编码成比特流。

16.根据权利要求14所述的编码系统，其中：

编码系统还适于接收照相机格子，照相机格子中的每个点与场景的一个输入视图关联，以及

视图产生单元适于进一步基于照相机格子来推导场景的所述一个或更多个视图。

17.根据权利要求16所述的编码系统，其中照相机格子中的每个点对于场景的每个输入视图包括关于与该输入视图关联的视图位置、视图角、视图方向、取向、以及水平和垂直尺寸中的一个或更多个的信息。

18.根据权利要求16所述的编码系统，其中照相机格子中的每个点对于场景的每个输入视图包括关于与该输入视图关联的视图位置、视图角、视图方向、取向、水平和垂直尺寸以及校正层中的一个或更多个的信息。

19.一种适于接收与场景关联的比特流并且适于产生一个或更多个输出图像的解码系统，该解码系统包括：

解码器，适于根据该比特流解码织锦图像和坐标图，其中该织锦图像和该坐标图与场景的多个输入视图关联；其中该织锦图像包括像素的2维阵列，该像素的2维阵列包括来自场景的多个输入视图的信息；其中坐标图包括与织锦图像的像素关联的位置数据；其中与织锦图像的像素关联的位置数据包括用于织锦图像中的每个像素的深度数据；以及其中与织锦图像的像素关联的位置数据还包括用于织锦图像中的每个像素的水平视差数据和/或垂直视差数据；以及

视图产生单元，适于基于该织锦图像和该坐标图来推导场景的一个或更多个输出图像。

20.根据权利要求19所述的解码系统，其中：

解码器还适于解码一个或更多个校正层，每个校正层与场景的一个输入视图关联，以及

视图产生单元适于进一步基于一个或更多个校正层来推导场景的所述一个或更多个输出图像。

21.根据权利要求19所述的解码系统，其中：

该解码器还适于解码照相机格子，以及

视图产生单元适于进一步基于照相机格子来推导场景的所述一个或更多个输出图像，其中照相机格子中的每个点与场景的一个输入视图关联。

22.根据权利要求20所述的解码系统，其中视图产生单元适于基于织锦图像和坐标图来推导第一组图像，该解码系统还包括：

结合单元，适于将来自第一组图像中的图像与对应的校正层结合以便产生该一个或更多个输出图像中的输出图像，其中来自第一组图像中的该图像、该校正层和所产生的输出图像与场景的相同的输入视图关联。

23.根据权利要求21所述的解码系统，其中照相机格子中的每个点对于场景的每个输入视图包括关于与该输入视图关联的视图位置、视图角、视图方向、取向、以及水平和垂直尺寸中的一个或更多个的信息。

24.根据权利要求21所述的解码系统，其中照相机格子中的每个点对于场景的每个输入视图包括关于与该输入视图关联的视图位置、视图角、视图方向、取向、水平和垂直尺寸以及校正层中的一个或更多个的信息。

25.根据权利要求19所述的解码系统，其中视图产生单元适于通过基于织锦图像和坐标图执行纹理区域填充来推导场景的一个或更多个输出图像。