如何与QUOT;陷阱＆QUOT;我表面补丁，以prevent从贯穿裂缝出血的背景是什么？ [英] How to "trap" my surface patches to prevent the background from bleeding through the cracks?
问题描述
在响应挑战的补偿。 lang.postscript，我的工作，我的3D扒试图呈现一个圆柱体的投影矩形补丁。但我仍然看到线框即使我注释掉线，绘图，因为补丁没有对接起来冲洗。
气缸沿着z轴通过仿照双遍历Z（-2。2，步骤4 / N）和θ（0 ... 360，步骤360 / N）。四个点的矩形的是：
- 在V1 =（R * CoS的T，R *罪T，Z）
- V4 =（R * CoS的T，R *罪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，做一个跨产品，以获取该补丁程序的法向量。以一个点积用眼矢量以检查补丁上的此岸的形状;如果不是，则跳过图和PROCEDE到下一补丁（脱落环的底部）。然后，我们应用透视投影到每个点，并绘制与常规的PostScript 2D通过MoveTo和LineTo等四边形。在法向量的最后一个计算，以设置灰度值，然后填写。
所以，问题是：的是有一个通常的方式来处理这个？它是一个三维的问题或只是一个数字问题（浮点舍入类似的东西）？难道我计算积分时，只需加一点软糖因素，以我的DZ和dT的？或中风的边缘明确？最后这两个选项都产生所期望的结果，但我不能说，我很满意他们。虽然每个化妆可以在一个单独的说明使用，它并没有真正的解决问题的，你知道吗？
我把正在使用的点转储。下面是N = 12的前几个。
在我看来，作为predicted，v2和v3不谋而合precisely与V1和下一个片上的带的V4。这些都是2D用户坐标系传递给通过MoveTo 和了lineTo 生产的各个四边形。由于CTM不会改变，这点应映射到相同的像素，对不对？因此它似乎是一个非常类似的问题的链接的问题。但我使用后记precisely，因为我不想渣土，大约有写我自己的光栅化程序:)。我真的觉得从链接的问题，映射到后记的解决方案，将是反向交替棋盘方格，至少连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输出不会出现问题，presumably由于有损玉米pression。所以这里有一个PNG快照。
的效果更加明显，如果使用眼矢量作为光源。这里的xpost左侧显示上呈现出的修改，其中DZ和DT是由1.06修正因子乘以权的问题和GS。
而code：[不要使用此code。有一个在MATMUL常规的误差。更正后的日常使用 rel="nofollow">。这里完成挑战提供。]
％！
％A阴影缸！呜呼！
％（mat.ps）运行
％！
％mat.ps
％矩阵与向量数学例程
/.error其中{流行/ signalerror {.error} DEF}如果
/点{％U v
2副本长度可置换长度NE {
/点CVX / undefinedresult signalerror
} 如果
％U v
0％U v总和
0 1 3索引长度1分{％U v总和我
3指数1指数GET EXCH％U v总和u_i我
3指标可置换获取％U v总和u_i V_I
MUL添加％U v总和
}用于％U v总和
3 1卷砰砰砰砰％之和
}绑定高清
％[X1 X2 X3] [Y1 Y2 Y3]交[X2 * Y3-Y2 * X3 X3 * Y1-X1 * Y3 X1 * Y2-X2 * Y1]
/交叉{％U v
DUP长度3 NE
2索引长度3 NE或{
/交叉CVX / undefinedresult signalerror
} 如果
％U v
可置换aload流行4 3卷aload弹出％X1 X2 X3 Y1 Y2 Y3
[
5索引2索引MUL％... [X2 * Y3
3指数6指数MUL子％... [X2 * Y3-Y2 * X3
5索引5索引MUL％... [X2 * Y3-Y2 * X3 X3 * Y1
8索引4索引MUL子％... [X2 * Y3-Y2 * X3 X3 * Y1-X1 * Y3
8索引5索引MUL％... [X2 * Y3-Y2 * X3 X3 * Y1-X1 * Y3 X1 * Y2
8索引7索引MUL子％... [X2 * Y3-Y2 * X3 X3 * Y1-X1 * Y3 X1 * Y2-X2 * Y1
]
7 1卷6 {}弹出重复
}绑定高清
/转{STATICDICT开始
/ A可置换DEF
/米长DEF
/ N A 0获取长度DEF
[
0 1 N + 1次{/ N可置换DEF
[
0 1 M 1分{/ M可置换DEF
A M得到n个获得
} 对于
]
} 对于
]
结束} DUP 0 6字典把高清
/ MATMUL {STATICDICT开始
/ B可置换DEF
B 0，获取型/ NE将ArrayType {/ B [B] DEF}如果
/ A可置换DEF
A 0获取型/ NE将ArrayType {/ A [A] DEF}如果
/ Q B长度高清
/ R B 0获取长度DEF
/ P的长度高清
Q A 0获取长度NE {
/ A A转高清
/ P的长度高清
Q A 0获取长度NE {
A，B端/ MATMUL CVX / undefinedresult signalerror
} 如果
} 如果
[
0 1 R 1分{/ R可置换DEF
[
0 1 P 1分{/对可置换DEF
0
0 1 Q 1次{/ Q可置换DEF
在P获取q GET
乙q GETř获取MUL
加
} 对于
} 对于
]
} 对于
]
结束} DUP 0 10字典把高清
％U V {}运营商VOP U（OP）V
％应用二进制运算符来相应的元素
％在两个向量产生第三向量作为结果
/ VOP {1字典开始
/ OP可置换DEF
2副本长度可置换长度NE {
/ VOP CVX端/ undefinedresult signalerror
} 如果
[3 1卷％[U v
0 1 2索引长度1分{％[...üV I
3副本可置换的流行得到％U V I u_i
3副本流行GET％U V I u_i V_I
操作可置换弹出％U v u_i（OP）V-I
3 1卷％u_i（OP）V-Iüv
}用于％[...üv
砰砰砰砰]
结束} DEF
一个向量的长度％
/ MAG {0可置换{DUP MUL附加}} FORALL高清
％x和yž昂 - ＆GT; X Y'Z'
/ ROTX {3字典开始
/ THETA可置换DEF
/ Z可置换DEF
/ Y可置换DEF
ŸTHETA余弦MUL
žTHETA罪MUL子
ŸTHETA罪MUL
žTHETA余弦MUL添加
结束} DEF
％x和yž昂 - ＆GT; X'ÿZ'
/ ROTY {4字典开始
/ THETA可置换DEF
/ Z可置换DEF
/ Y可置换DEF
/ X可置换DEF
x THETA余弦MUL
žTHETA罪MUL添加
ÿ
x THETA罪MUL负
žTHETA余弦MUL添加
结束} DEF
％x和yž昂 - ＆GT; X'Y'ž
/ ROTZ {4字典开始
/ THETA可置换DEF
/ Z可置换DEF
/ Y可置换DEF
/ X可置换DEF
x THETA余弦MUL
ŸTHETA罪MUL子
x THETA罪MUL
ŸTHETA余弦MUL添加
ž
结束} DEF
％x和yž - ＆GT; X'Y'Z'
/模型 {
％昂ROTY
％昂0.25 MUL ROTX
％αROTZ
公测ROTY
伽玛ROTX
} DEF
％眼COORDS
/ EX .1 DEF
/ EY .1 DEF
/ EZ 5 DEF
/ eyedir [EX EY EZ]
DUP MAG [可置换DUP DUP] {DIV} VOP
DEF
％x和yž - ＆GT; X Y
/项目 {
3字典开始
/ Z可置换DEF
/ Y可置换DEF
/ X可置换DEF
1 EZž分格
x EZ MULž前MUL子
1指数MUL
ŸEZ MULž安永MUL子
3 2卷MUL
结束} DEF
/光
[3 -7 -2 1]
DUP MAG [可置换DUP DUP DUP] {DIV} VOP
DEF
/ IA 0.4 DEF％的入射环境光强
/嘉0.4 DEF％环境漫反射常数
/ IL 0.5 DEF％事变Lightsource强度
/ K D 0.3 DEF％漫反射常数
％H R N
/气缸{20字典开始
/ N可置换DEF
/ R可置换DEF
/ h的可置换DEF
/ DZ 1N的DIV高清
/ DT 360 DZ MUL高清
/克民共体^ h DZ MUL高清
0 DZ 1 DZ子{
^ h MUL H 2格分/ Z可置换DEF
0 DT 360 {/吨可置换DEF
/ V1 [T COS - [R MUL
牛逼的罪 - [R MUL
Z]高清
/ V4 [V1 aload砰砰砰砰
žHDZ添加]高清
/ T（T）DT加DEF
/ V2 [T COS - [R MUL
牛逼的罪 - [R MUL
Z]高清
/ V3 [V2 aload砰砰砰砰
žHDZ添加]高清
[V1 V2 V3 V4] {
aload 4 1卷模式4 3卷ASTORE流行
} 对全部
/正常V4 V1 {}子VOP
V2 V1 {}子VOP
穿越高清
/ nlen正常MAG高清
/正常正常[nlen nlen nlen] {DIV} VOP高清
[正常aload弹出1] [eyedir aload弹出1点0其中{
/动作{通过MoveTo /动作{}了lineTo DEF} DEF
[V1 V2 V3 V4]
{aload流行的项目动作}
对全部
调用closePath
％gsave
[正常aload弹出1]
光
％[EX EY EZ负1％喜洋洋
点
伊尔的Kd MUL MUL
IA嘉MUL添加
setgray
填
％grestore
％ 行程
} 如果
} 对于
} 对于
结束} DEF
300 400翻译
280 DUP DUP通过MoveTo
DUP负DUP负了lineTo
DUP负DUP了lineTo
DUP负了lineTo调用closePath 0.6 setgray填写
1 70 DUP DUP规模DIV setlinewidth
％/公测0闪避
％/伽玛0闪避
％4 2 50缸
/ 90测试版高清
/伽玛0闪避
4 2 50缸
％/公测0闪避
％/伽玛90 DEF
％4 2 50缸
SHOWPAGE
好吧，我已经出来的东西，坐落在肠道更容易一些。
6％捏造就觉得到可怕的负担。
但是肯建议可以参与四舍五入。这意味着采取四舍五入的控制应该获得一个控制了一定程度上的问题。它看起来就像是真的。
所以，我想prepending所有通过MoveTo 和了lineTo 通过调用调用 $ P $页：
/ $ P $ {页
转换
％2 {
％可置换
％地板
回合
％天花板
％2 MUL CVI 2 DIV％圆
％} 重复
itransform
} DEF
中的注释说明的各个部分我试过了。既取整设备上的坐标消除了所有的水平放线，并留下非常薄的垂直出血。这似乎是有道理的假设Ghostscript的栅格化通过水平扫描线：它有一个更简单的时间和水平的人有一点点帮助，但接近垂直的强硬。
但后来我结合这与捏造。而且我发现，圆刚设备-Y'坐标和2％捏造补丁尺寸消除了所有的出血。这真的点亮了这个蝙蝠洞。
2％是捏造的一个可接受的水平，我想。 （？）
不幸的是，上述所有要求时，调整N的值（片数）调整。以覆盖整个表面的最简单的解决办法是在行程相同的颜色填充的边缘。唯一的难点这里是确保的线宽是适当的规模。而最简单的方式做到这一点是设置他们两个在一起。对于非常高的分辨率，这可能应该以某种方式解释对于N调整。
1 70 DUP DUP规模DIV setlinewidth
下面是由最后的程序所产生的图像中的一个，一斯坦梅茨固体与坐标轴和随机颜色，以略微歪斜的透视图（其右脚伸出一点）。
In response to a challenge in comp.lang.postscript, I'm working-up my 3D chops trying to render a cylinder as projected rectangular patches. But I'm still seeing the wire-frame even after I comment-out the line-drawing, because the patches don't butt-up flush.
The cylinder is modeled along the z-axis by double-looping over z (-2 .. 2, step 4/N) and theta (0 .. 360, step 360/N). The four points of the rectangle are:
- 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)
Then we apply a model->world rotation to all four points. Then we take the vectors v1->v4 and v1->v2 and do a cross product to get the normal vector for the patch. Take a dot product with the eye vector to check if the patch is on "this side" of the shape; if not, skip the drawing and procede to the next patch (fall off the bottom of the loop). Then we apply a perspective projection to each point and draw the quadrilateral with regular postscript 2D moveto and lineto. One last calculation on the normal vector to set the graylevel and then fill.
So the question is: Is there a usual way to deal with this? Is it a 3D problem or just a numerical problem (floating-point round-off kind of stuff)? Do I just add a little fudge-factor to my dz and dT when calculating the points? Or stroke the edges explicitly? These last 2 options both produce the desired result but I can't say that I'm satisfied with them. While each make be used on an individual illustration, it doesn't really solve the problem, you know?
I took a dump of the points being used. Here's the first few from N=12.
It appears to me that, as predicted, v2 and v3 coincide precisely with v1 and v4 of the next piece on the band. These are the 2D "user coordinates" passed to moveto and lineto to produce the individual quadrilaterals. Since the CTM doesn't change, these points should map to the same pixels, right? So it does appear to be a very similar issue to the linked question. But I'm using Postscript precisely because I don't want to muck-about with writing my own rasterization routine :). I really think that the solution from the linked question, mapped to Postscript, would be to reverse the orientation of alternating checkerboard squares, at least for even N. That way, all corresponding edges are drawn in the same direction (as each other).
[-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]
I've added a simple light model and tweaked it to bring out more mids. Jpeg output doesn't exhibit the problem, presumably due to the lossy compression. So here's a PNG snapshot.
The effect is much more apparent if I use the eye-vector as the light source. Here's xpost on the left showing the problem and gs on the right showing a modification where dz and dt are multiplied by a fudge factor of 1.06.
And the code: [Do not use this code. There is an error in the matmul routine. Corrected routines available here. Completed challenge available here.]
%!
%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
Alright, I've come up with something that sits a little easier in the gut.
6% fudging just feels to horrible to bear.
But Ken suggested that rounding could be involved. That means taking control of the rounding should gain one some measure of control over the problem. And it looks like it's true.
So I tried prepending all moveto and lineto calls with a call to prep:
/prep {
transform
%2 {
% exch
%floor
round
%ceiling
%2 mul cvi 2 div %round
%} repeat
itransform
} def
The comments show the various pieces I tried. Rounding on both device coordinates eliminated all horizontal bleed-lines and leaves very thin vertical bleeds. This seems to make sense assuming Ghostscript rasterizes by horizontal scanlines: it has an easier time with the horizontal ones with just a little help, but near-verticals are tougher.
But then I combined this with fudging. And I found that rounding just the device-y 'ordinate and fudging the patch dimensions by 2% eliminates all bleeds. It really lit up this batcave.
2% is an acceptable level of fudging, I think. (?)
Unfortunately, all the above requires tweaking when you adjust the value of N (the number of slices). The simplest fix to cover the whole surface is to stroke the edges in the same color as the fill. The only difficult point here is making sure the linewidth is appropriate for the scale. And the easy way to do that is to set them both together. For very high resolutions, this should probably be adjusted in some way to account for N.
1 70 dup dup scale div setlinewidth
Here's one of the images generated by the final program, a Steinmetz solid with coordinate axes and random colors, in a slightly skewed perspective (its right foot sticks out a little).
这篇关于如何与QUOT;陷阱＆QUOT;我表面补丁，以prevent从贯穿裂缝出血的背景是什么？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
