0

为了应对 comp.lang.postscript 中的挑战，我正在处理我的 3D 印章，试图将圆柱体渲染为投影的矩形补丁。但即使在我注释掉线条图后，我仍然看到线框，因为补丁不会齐平。

通过在 z (-2 .. 2, step 4/N) 和 theta (0 .. 360, step 360/N) 上双循环，沿 z 轴对圆柱体进行建模。矩形的四个点是：

  • v1 = (R cos T, R sin T, z)
  • v4 = (R cos T, R sin T, z+dz)
  • v2 = (R cos (T+dT), R sin (T+dt), z)
  • v3 = (R cos (T+dT), R sin (T+dt), z+dz)

然后我们对所有四个点应用模型->世界旋转。然后我们取向量 v1->v4 和 v1->v2 并进行叉积以获得补丁的法线向量。用眼睛矢量进行点积，检查补丁是否在形状的“这一侧”；如果没有，请跳过绘图并继续下一个补丁（从循环底部掉下来）。然后我们对每个点应用透视投影，并使用常规后记 2D moveto 和 lineto 绘制四边形。对法线向量进行最后一次计算以设置灰度级，然后进行填充。

所以问题是：有没有通常的方法来处理这个问题？它是一个 3D 问题还是只是一个数值问题（浮点舍入之类的东西）？在计算点数时，我是否只是在我的 dz 和 dT 中添加了一些软糖因素？或者明确地抚摸边缘？最后两个选项都产生了预期的结果，但我不能说我对它们感到满意。虽然每个制作都用于单独的插图，但它并不能真正解决问题，你知道吗？

我把正在使用的积分转储了。这是 N=12 的前几个。在我看来，正如预测的那样，v2 和 v3 与乐队下一段的 v1 和 v4 恰好重合。moveto这些是传递给并lineto生成各个四边形的二维“用户坐标” 。由于 CTM 没有改变，这些点应该映射到相同的像素，对吧？因此，它似乎与链接问题非常相似。但我使用 Postscript 正是因为我不想写自己的光栅化例程 :)。我真的认为映射到 Postscript 的链接问题的解决方案是反转交替棋盘格的方向，至少对于 N 来说。这样，所有对应的边都是以相同的方向（彼此）绘制。

[-2.64550757 2.08465409]
[-3.00470281 1.69015563]
[-2.7090168 1.69015563]
[-2.38403082 2.08465409]

[-3.00470281 1.69015563]
[-3.28940701 0.936108589]
[-2.96660638 0.936108589]
[-2.7090168 1.69015563]

[-3.28940701 0.936108589]
[-3.4 -0.0666666701]
[-3.0666666 -0.0666666701]
[-2.96660638 0.936108589]

[-3.4 -0.0666666701]
[-3.28940701 -1.05890918]
[-2.96660638 -1.05890918]
[-3.0666666 -0.0666666701]

[-3.28940701 -1.05890918]
[-3.00470281 -1.78584146]
[-2.7090168 -1.78584146]
[-2.96660638 -1.05890918]

我添加了一个简单的灯光模型并对其进行了调整以产生更多的中频。Jpeg 输出没有出现问题，可能是由于有损压缩。所以这是一个PNG快照。

PNG 快照

如果我使用眼睛矢量作为光源，效果会更加明显。左边的 xpost 显示了问题，右边的 gs 显示了修改，其中 dz 和 dt 乘以 1.06 的软糖因子。

眼光裂缝和软糖

和代码：[不要使用这个代码。matmul 例程中有错误。更正的例程可在此处获得。已完成的挑战可在此处获得。]

%!
%A shaded cylinder! Woohoo!

%(mat.ps) run
%!
%mat.ps
%Matrix and Vector math routines

/.error where { pop /signalerror { .error } def } if

/dot { % u v
    2 copy length exch length ne {
        /dot cvx /undefinedresult signalerror
    } if
    % u v
    0 % u v sum
    0 1 3 index length 1 sub { % u v sum i
        3 index 1 index get exch % u v sum u_i i
        3 index exch get % u v sum u_i v_i
        mul add % u v sum
    } for % u v sum

    3 1 roll pop pop % sum
} bind def

% [ x1 x2 x3 ] [ y1 y2 y3 ]  cross  [ x2*y3-y2*x3 x3*y1-x1*y3 x1*y2-x2*y1 ]
/cross { % u v
    dup length 3 ne
    2 index length 3 ne or {
        /cross cvx /undefinedresult signalerror
    } if
    % u v
    exch aload pop 4 3 roll aload pop % x1 x2 x3 y1 y2 y3
    [
        5 index 2 index mul % ... [ x2*y3
        3 index 6 index mul sub % ... [ x2*y3-y2*x3
        5 index 5 index mul % ... [ x2*y3-y2*x3 x3*y1
        8 index 4 index mul sub % ... [ x2*y3-y2*x3 x3*y1-x1*y3
        8 index 5 index mul % ... [ x2*y3-y2*x3 x3*y1-x1*y3 x1*y2
        8 index 7 index mul sub % ... [ x2*y3-y2*x3 x3*y1-x1*y3 x1*y2-x2*y1
    ]
    7 1 roll 6 { pop } repeat
} bind def

/transpose { STATICDICT begin
    /A exch def
    /M A length def
    /N A 0 get length def
    [
    0 1 N 1 sub { /n exch def
        [
        0 1 M 1 sub { /m exch def
            A m get n get
        } for
        ]
    } for
    ]
end } dup 0 6 dict put def

/matmul { STATICDICT begin
    /B exch def
    B 0 get type /arraytype ne { /B [B] def } if
    /A exch def
    A 0 get type /arraytype ne { /A [A] def } if
    /Q B length def
    /R B 0 get length def
    /P A length def
    Q A 0 get length ne {
        /A A transpose def
        /P A length def
        Q A 0 get length ne {
            A B end /matmul cvx /undefinedresult signalerror
        } if
    } if

    [
    0 1 R 1 sub { /r exch def
        [
        0 1 P 1 sub { /p exch def
            0
            0 1 Q 1 sub { /q exch def
                A p get q get
                B q get r get mul
                add
            } for
        } for
        ]
    } for
    ]

end } dup 0 10 dict put def

%u v {operator}  vop  u(op)v
%apply a binary operator to corresponding elements
%in two vectors producing a third vector as result
/vop { 1 dict begin
    /op exch def
    2 copy length exch length ne {
        /vop cvx end /undefinedresult signalerror
    } if

    [ 3 1 roll % [ u v
    0 1 2 index length 1 sub { % [ ... u v i
        3 copy exch pop get % u v i u_i
        3 copy pop get      % u v i u_i v_i
        op exch pop         % u v u_i(op)v_i
        3 1 roll            % u_i(op)v_i u v
    } for % [ ... u v
    pop pop ]

end } def


%length of a vector
/mag { 0 exch { dup mul add } forall } def

% x y z ang -> x y' z'
/rotx { 3 dict begin
    /theta exch def
    /z exch def
    /y exch def
    y theta cos mul
    z theta sin mul sub
    y theta sin mul
    z theta cos mul add
end } def

% x y z ang -> x' y z'
/roty { 4 dict begin
    /theta exch def
    /z exch def
    /y exch def
    /x exch def
    x theta cos mul
    z theta sin mul add
    y
    x theta sin mul neg
    z theta cos mul add
end } def

% x y z ang -> x' y' z
/rotz { 4 dict begin
    /theta exch def
    /z exch def
    /y exch def
    /x exch def
    x theta cos mul
    y theta sin mul sub
    x theta sin mul
    y theta cos mul add
    z
end } def

% x y z -> x' y' z'
/model {
%ang roty
%ang .25 mul rotx
%alpha rotz
beta roty
gamma rotx
} def

% Eye coords
/ex .1 def
/ey .1 def
/ez 5 def
/eyedir [ex ey ez]
    dup mag [ exch dup dup ]{div} vop
def

% x y z -> X Y
/project {
3 dict begin
    /z exch def
    /y exch def
    /x exch def
    1 ez z sub div
    x ez mul z ex mul sub
    1 index mul
    y ez mul z ey mul sub
    3 2 roll mul
end } def

/light
    [ 3 -7 -2 1 ]
    dup mag [ exch dup dup dup ]{div} vop
def
/Ia .4 def % Incident Ambient Intensity
/Ka .4 def % Ambient Diffuse reflection constant
/Il .5 def % Incident intensity of Lightsource
/Kd .3 def % Diffuse reflection constant

%h R N
/cylinder { 20 dict begin
    /N exch def
    /R exch def
    /h exch def
    /dz 1 N div def
    /dt 360 dz mul def
    /hdz h dz mul def

    0 dz 1 dz sub {
        h mul h 2 div sub /z exch def

        0 dt 360 { /t exch def
            /v1 [ t cos R mul
                t sin R mul
                z ] def
            /v4 [ v1 aload pop pop
                z hdz add ] def
            /t t dt add def
            /v2 [ t cos R mul
                t sin R mul
                z ] def
            /v3 [ v2 aload pop pop
                z hdz add ] def
            [ v1 v2 v3 v4 ] {
                aload 4 1 roll model 4 3 roll astore pop
            } forall
            /normal v4 v1 {sub} vop
                    v2 v1 {sub} vop
                    cross def
            /nlen normal mag def
            /normal normal [nlen nlen nlen] {div} vop def
            [normal aload pop 1] [eyedir aload pop 1] dot 0 lt {
                /action { moveto /action { lineto } def } def
                [ v1 v2 v3 v4 ]
                { aload pop project action }
                forall
                closepath
%                gsave
                    [normal aload pop 1]
                    light
                    %[ex ey ez neg 1] %"radiant"
                    dot
                    Il Kd mul mul
                    Ia Ka mul add
                    setgray
                    fill
%                grestore
%                stroke
            } if

        } for
    } for
end } def

300 400 translate
280 dup dup moveto
dup neg dup neg lineto
dup neg dup lineto
dup neg lineto closepath .6 setgray fill
1 70 dup dup scale div setlinewidth

%/beta 0 def
%/gamma 0 def
%4 2 50 cylinder

/beta 90 def
/gamma 0 def
4 2 50 cylinder

%/beta 0 def
%/gamma 90 def
%4 2 50 cylinder

showpage
4

1 回答 1

0

好吧，我想出了一些更容易让人接受的东西。

6% 的捏造感觉太可怕了。

但肯建议可能涉及四舍五入。这意味着控制舍入应该获得对问题的某种控制措施。看起来这是真的。

所以我尝试在 allmoveto和linetocall 前面加上一个电话prep：

/prep {
    transform
    %2 {
    %    exch
        %floor
        round
        %ceiling
        %2 mul cvi 2 div %round
    %} repeat
    itransform
} def

评论显示了我尝试过的各种作品。两个设备坐标上的舍入消除了所有水平出血线并留下非常薄的垂直出血。假设 Ghostscript 通过水平扫描线进行光栅化，这似乎是有道理的：只需一点帮助，它就可以更轻松地使用水平扫描线，但近乎垂直的扫描线更难。

但后来我把它和捏造结合起来了。而且我发现仅将设备-y'坐标四舍五入并将补丁尺寸缩小2％可以消除所有出血。它真的照亮了这个蝙蝠洞。

我认为 2% 是可以接受的捏造水平。（？）

不幸的是，当您调整 N 的值（切片数）时，上述所有内容都需要进行调整。覆盖整个表面的最简单修复方法是用与填充相同的颜色描边边缘。这里唯一的难点是确保线宽适合比例。最简单的方法是将它们放在一起。对于非常高的分辨率，这可能应该以某种方式调整以考虑 N。

1 70 dup dup scale div setlinewidth

这是最终程序生成的图像之一，一个带有坐标轴和随机颜色的 Steinmetz 实体，透视图略微倾斜（它的右脚有点突出）。

Steinmetz 立体透视

于 2012-09-10T06:55:21.257 回答