我已经用julia编程语言编写了一个路径跟踪器，但我认为它很慢

我已经更改了我的帖子并发布了我的全部代码！有人能告诉我如何优化它吗

import Base: *, +, -, /, ^
using Images
const Π = convert(Float64, π)

#define vector
mutable struct Vec3
    x::Float64
    y::Float64
    z::Float64
end

function +(u::Vec3, v::Vec3)
    Vec3(u.x+v.x, u.y+v.y, u.z+v.z)
end

function -(u::Vec3, v::Vec3)
    Vec3(u.x-v.x, u.y-v.y, u.z-v.z)
end

function /(u::Vec3, v::Float64)
    Vec3(u.x/v, u.y/v, u.z/v)
end

function *(u, v::Vec3)
    if typeof(u) == Float64
        Vec3(u*v.x, u*v.y, u*v.z)
    elseif typeof(u) == Vec3
        Vec3(u.x*v.x, u.y*v.y, u.z*v.z)
    end
end

function ^(u::Vec3, v::Float64)
    Vec3(u.x^v, u.y^v, u.z^v)
end

function dot(u::Vec3, v::Vec3)
    u.x*v.x + u.y*v.y + u.z*v.z
end

function normalize(u::Vec3)
    u/sqrt(dot(u,u))
end

function cross(u::Vec3, v::Vec3)
    Vec3(u.y*v.z - v.y*u.z, u.z*v.x - v.z*u.x, u.x*v.y - v.x*u.y)
end

function gamma(u::Vec3)
    Vec3(u.x^(1/2.2), u.y^(1/2.2), u.z^(1/2.2))
end

function clamp(u::Vec3)
    u.x = u.x <= 1 ? u.x : 1
    u.y = u.y <= 1 ? u.y : 1
    u.z = u.z <= 1 ? u.z : 1
    u
end

#define ray
struct Ray
    s::Vec3
    d::Vec3
end

#define planes
struct xyRect
    z; x1; x2; y1; y2::Float64
    normal; emittance; reflectance::Vec3
    isLight::Bool
end

struct xzRect
    y; x1; x2; z1; z2::Float64
    normal; emittance; reflectance::Vec3
    isLight::Bool
end

struct yzRect
    x; y1; y2; z1; z2::Float64
    normal; emittance; reflectance::Vec3
    isLight::Bool
end

#define sphere
mutable struct Sphere
    radius::Float64
    center; normal; emittance; reflectance::Vec3
    isLight::Bool
end

#define empty object
struct Empty
    normal; emittance; reflectance::Vec3
end

#define surfaces
Surfaces = Union{xyRect, xzRect, yzRect, Sphere}

#define intersection function
function intersect(surface::Surfaces, ray::Ray)
if typeof(surface) == xyRect
    t = (surface.z - ray.s.z)/ray.d.z
    if surface.x1 < ray.s.x + t*ray.d.x < surface.x2 && surface.y1 < ray.s.y + t*ray.d.y < surface.y2 && t > 0
        t
    else
        Inf
    end

elseif typeof(surface) == xzRect
    t = (surface.y - ray.s.y)/ray.d.y
    if surface.x1 < ray.s.x + t*ray.d.x < surface.x2 && surface.z1 < ray.s.z + t*ray.d.z < surface.z2 && t > 0
        t
    else
        Inf
    end

elseif typeof(surface) == yzRect
    t = (surface.x - ray.s.x)/ray.d.x
    if surface.y1 < ray.s.y + t*ray.d.y < surface.y2 && surface.z1 < ray.s.z + t*ray.d.z < surface.z2 && t > 0
        t
    else
        Inf
    end

elseif typeof(surface) == Sphere
    a = dot(ray.d, ray.d)
    b = 2dot(ray.d, ray.s - surface.center)
    c = dot(ray.s - surface.center, ray.s - surface.center) - surface.radius*surface.radius
    Δ = b*b - 4*a*c
    if Δ > 0
        Δ = sqrt(Δ)
        t1 = 0.5(-b-Δ)/a
        t2 = 0.5(-b+Δ)/a
        if t1 > 0
            surface.normal = normalize(ray.s + t1*ray.d - surface.center)
            t1
        elseif t2 > 0
            surface.normal = normalize(ray.s + t2*ray.d - surface.center)
            t2
        else
            Inf
        end
    else
        Inf
    end
end
end
#define nearest function
function nearest(surfaces::Array{Surfaces, 1}, ray::Ray, tMin::Float64)
    hitSurface = Empty(Vec3(0,0,0), Vec3(0,0,0), Vec3(0,0,0))
    for surface in surfaces
        t = intersect(surface, ray)
        if t < tMin
            tMin = t
            hitSurface = surface
        end
    end
    tMin, hitSurface
end
#cosine weighted sampling of hemisphere
function hemiRand(n::Vec3)
    ξ1 = rand()
    ξ2 = rand()
    x = cos(2π*ξ2)*sqrt(ξ1)
    y = sin(2π*ξ2)*sqrt(ξ1)
    z = sqrt(1-ξ1)
    r = normalize(Vec3(2rand()-1, 2rand()-1, 2rand()-1))
    b = cross(n,r)
    t = cross(n,b)
    Vec3(x*t.x + y*b.x + z*n.x, x*t.y + y*b.y + z*n.y, x*t.z + y*b.z + z*n.z)
end
#trace the path
function trace(surfaces::Array{Surfaces, 1}, ray::Ray, depth::Int64, maxDepth::Int64)
    if depth >= maxDepth
        return Vec3(0,0,0)
    end
    t, material = nearest(surfaces, ray, Inf)
    if typeof(material) == Empty
        return Vec3(0,0,0)
    end
    if material.isLight == true
        return material.emittance
    end
    ρ = material.reflectance
    BRDF = ρ/Π
    n = material.normal
    R = hemiRand(n)
    In = trace(surfaces, Ray(ray.s + t*ray.d, R), depth+1, maxDepth)
    return Π*BRDF*In
end
#define camera
struct Camera
    eye; v_up; N::Vec3
    fov; aspect; distance::Float64
end    
#render function
function render(surfaces::Array{Surfaces,1},camera::Camera,xRes::Int64,yRes::Int64,numSamples::Int64,maxDepth::Int64)
    n = normalize(camera.N)
    e = camera.eye
    c = e - camera.distance*n
    θ = camera.fov*(π/180)
    H = 2*camera.distance*tan(θ/2)
    W = H*camera.aspect
    u = normalize(cross(camera.v_up,n))
    v = cross(n,u)
    img = zeros(3, xRes, yRes)
    pixHeight = H/yRes
    pixWidth = W/xRes
    L = c - 0.5*W*u - 0.5*H*v
    for i=1:xRes
        for j=1:yRes
            cl = Vec3(0,0,0)
            for s=1:numSamples
                pt = L + (i-rand())*pixWidth*u + (yRes-j+rand())*pixHeight*v
                cl = cl + trace(surfaces, Ray(e, pt-e), 0, maxDepth)
            end
            cl = gamma(clamp(cl/convert(Float64, numSamples)))
            img[:,j,i] = [cl.x, cl.y, cl.z]
        end
    end
    img
end
#the scene
p1 = xzRect(1.,0.,1.,-1.,0.,Vec3(0,-1,0),Vec3(0,0,0),Vec3(0.75,0.75,0.75),false)
p2 = xzRect(0.,0.,1.,-1.,0.,Vec3(0,1,0),Vec3(0,0,0),Vec3(0.75,0.75,0.75),false)
p3 = xyRect(-1.,0.,1.,0.,1.,Vec3(0,0,1),Vec3(0,0,0),Vec3(0.75,0.75,0.75),false)
p4 = yzRect(0.,0.,1.,-1.,0.,Vec3(1,0,0),Vec3(0,0,0),Vec3(0.75,0.25,0.25),false)
p5 = yzRect(1.,0.,1.,-1.,0.,Vec3(-1,0,0),Vec3(0,0,0),Vec3(0.25,0.25,0.75),false)
p6 = xzRect(0.999,0.35,0.65,-0.65,-0.35,Vec3(0,-1,0),Vec3(18,18,18),Vec3(0,0,0),true)
s1 = Sphere(0.15,Vec3(0.3,0.15,-0.6),Vec3(0,0,0),Vec3(0,0,0),Vec3(0.75,0.75,0.75),false)
surfs = Surfaces[p1,p2,p3,p4,p5,p6,s1]
cam = Camera(Vec3(0.5,0.5,2),Vec3(0,1,0),Vec3(0,0,1),28.07,1,2)
@time image = render(surfs, cam, 400, 400, 1, 4);
colorview(RGB, image)

import Base:*，+，-，/^
使用图像
常数∏=转换（浮点64，π）
#定义向量
可变结构Vec3
x:：Float64
y：：浮动64
z:：Float64
结束
函数+（u:：Vec3，v:：Vec3）
Vec3（u.x+v.x，u.y+v.y，u.z+v.z）
结束
函数-（u:：Vec3，v:：Vec3）
Vec3（u.x-v.x，u.y-v.y，u.z-v.z）
结束
函数/（u:：Vec3，v:：Float64）
Vec3（u.x/v、u.y/v、u.z/v）
结束
函数*（u，v：：Vec3）
如果类型（u）=64
Vec3（u*v.x，u*v.y，u*v.z）
elseif typeof（u）=Vec3
Vec3（u.x*v.x，u.y*v.y，u.z*v.z）
结束
结束
函数^（u:：Vec3，v:：Float64）
Vec3（u.x^v，u.y^v，u.z^v）
结束
函数点（u:：Vec3，v:：Vec3）
u、 x*v.x+u.y*v.y+u.z*v.z
结束
函数规格化（u:：Vec3）
u/sqrt（dot（u，u））
结束
函数交叉（u:：Vec3，v:：Vec3）
Vec3（u.y*v.z-v.y*u.z，u.z*v.x-v.z*u.x，u.x*v.y-v.x*u.y）
结束
函数gamma（u：：Vec3）
Vec3（u.x^（1/2.2）、u.y^（1/2.2）、u.z^（1/2.2））
结束
功能钳位（u:：Vec3）
u、 x=u.x 0
T
其他的
Inf
结束
elseif类型（表面）=球体
a=点（光线d，光线d）
b=2dot（光线d、光线s-表面中心）
c=点（光线.s-表面.中心，光线.s-表面.中心）-表面.半径*表面.半径
Δ=b*b-4*a*c
如果Δ>0
Δ=sqrt（Δ）
t1=0.5（-b-Δ）/a
t2=0.5（-b+Δ）/a
如果t1>0
surface.normal=规格化（光线.s+t1*光线.d-表面.中心）
t1
elseif t2>0
surface.normal=规格化（光线.s+t2*光线.d-表面.中心）
t2
其他的
Inf
结束
其他的
Inf
结束
结束
结束
#定义最近函数
函数最近（曲面：：数组{surfaces，1}，光线：：光线，tMin：：Float64）
hitSurface=Empty（Vec3（0,0,0），Vec3（0,0,0），Vec3（0,0,0））
用于曲面中的曲面
t=相交（曲面、光线）
如果t=最大深度
返回向量3（0,0,0）
结束
t、 材质=最近的（曲面、光线、Inf）
如果（材料）类型==空
返回向量3（0,0,0）
结束
如果material.isLight==true
返回材料发射度
结束
ρ=材料反射率
BRDF=ρ/π
n=材料。正常
R=hemiRand（n）
In=轨迹（曲面，光线（光线.s+t*光线.d，R），深度+1，最大深度）
返回∏BRDF*In
结束
#定义摄像机
结构摄像机
眼睛；v_up；N：：Vec3
视野；方面；距离：64
结束
#渲染功能
函数渲染（曲面：：数组{surfaces，1}，摄影机：：摄影机，xRes：：Int64，yRes：：Int64，numSamples：：Int64，maxDepth：：Int64）
n=标准化（camera.n）
e=照相机。眼睛
c=e-摄像机距离*n
θ=摄像机视场*（π/180）
H=2*摄像机距离*tan（θ/2）
W=H*摄像机的角度
u=标准化（交叉（摄像机v向上，n））
v=交叉（n，u）
img=零（3，X，Y）
pixHeight=H/yRes
pixWidth=W/xRes
L=c-0.5*W*u-0.5*H*v
对于i=1:xRes
对于j=1:yRes
cl=Vec3（0,0,0）
对于s=1:numSamples
pt=L+（i-rand（））*pixWidth*u+（yRes-j+rand（））*pixHeight*v
cl=cl+轨迹（表面，光线（e，pt-e），0，最大深度）
结束
cl=伽马（钳位（cl/转换（浮点64，numSamples）））
img[：，j，i]=[cl.x，cl.y，cl.z]
结束
结束
img
结束
#现场
p1=xzRect（1,0,1,1,0,Vec3（0，-1,0），Vec3（0,0,0），Vec3（0.75,0.75,0.75），假）
p2=xzRect（0,0,1.，-1,0,Vec3（0,1,0），Vec3（0,0,0），Vec3（0.75,0.75,0.75），false）
p3=xyRect（-1,0,1,0,1,0,1,Vec3（0,0,1），Vec3（0,0,0），Vec3（0.75,0.75,0.75），false）
p4=yzRect（0,0,1.，-1,0,Vec3（1,0,0），Vec3（0,0,0），Vec3（0.75,0.25,0.25），假）
p5=yzRect（1,0,1.，-1,0,Vec3（-1,0,0），Vec3（0,0,0），Vec3（0.25,0.25,0.75），假）
p6=xzRect（0.999,0.35,0.65，-0.65，-0.35，Vec3（0，-1,0），Vec3（18,18,18），Vec3（0,0,0），真）
s1=球体（0.15，Vec3（0.3,0.15，-0.6），Vec3（0,0,0），Vec3（0,0,0），Vec3（0.75,0.75,0.75），假）
表面粗糙度=表面[p1、p2、p3、p4、p5、p6、s1]
cam=摄像机（Vec3（0.5,0.5,2），Vec3（0,1,0），Vec3（0,0,1），28.07,1,2）
@时间图像=渲染（曲面、cam、400、400、1、4）；
彩色视图（RGB，图像）

我需要知道为什么我的代码是坏的和缓慢的。我是一个初学者程序员，我没有足够的经验。“我的路径跟踪器”场景包含7个对象，其最大深度为4，生成大小为400*400的图像需要2秒以上的时间。我认为它不应该那么慢，因为我的cpu是核心i7 4770。 很抱歉更改了我的帖子。

首先

struct yzRect
x; y1; y2; z1; z2::Float64
normal; emittance; reflectance::Vec3
isLight::Bool
end

最终仅将类型应用于每行的最后一个变量：

julia> fieldtypes(yzRect)
(Any, Any, Any, Any, Float64, Any, Any, Vec3, Bool)

所以Julia基本上不知道结构中会减慢速度的任何类型

此外，您的

Vec3

实际上应该是不可变的，当您想要“修改”向量时，您只需创建它的新实例

可能还有更多的问题，但这两个问题非常突出

---

在分析性能时，强烈建议通读并应用其中的指南。

这可能是一个次要问题，但在前面的问题中，建议您使用

a isa a

，而不是

typeof（a）==a

。您还可以通过为单独的曲面类型定义单独的

intersect

方法来清理代码，而不是使用大型开关站。如果添加新的曲面类型，它更容易阅读，更新也更方便