Celestia/Celx 脚本/CELX Lua 方法/Celx 观察者

Celx 脚本: 观察者

观察者

观察者对象用于访问特定于视图的属性，例如查看器位置、查看器方向、参考系和跟踪状态。可以使用 goto 命令或直接设置属性来操作查看器位置和方向。

在 CELX 脚本中，可以使用观察者方法作用于观察者对象，方法是在观察者对象和观察者方法之间用分号隔开。

以下方法可用于获取观察者对象

• 使用 celestia:getobserver() 方法针对活动视图。
• 使用 celestia:getobservers() 方法，在多视图情况下，这将生成一个包含每个视图的观察者对象的列表。

备注

1. 由于视图（以及观察者）可以由用户创建和销毁，因此 Lua 中的观察者对象可能变得无效。访问无效观察者对象会导致错误。
2. 为了方便处理观察者对象，您可以使用 “==“ 将它们与其他观察者对象进行比较，这对于其他 celx 对象来说是不可靠的。

方法

本章列出了所有可用的观察者方法，这些方法可用于 “观察者” 对象。

goto

observer:goto(object/position:target [, number:duration, number:start_interpolation, number:end_interpolation])

跳转到一个对象或位置，类似于在键盘上按 [G] 键。

参数

target

要跳转到的 “对象” 对象或 “位置” 对象。

duration [可选]

跳转所需的时间（以秒为单位）。默认值为 5 秒。

start_interpolation [可选]

跳转过程中，观察者应从初始方向开始转向最终方向的时间点（以 0 到 1 之间的百分数表示）。默认值为 0.25。

• 如果 start_interpolation 小于 0 或大于 1，则会调整为默认值。

end_interpolation [可选]

跳转过程中，观察者应从初始方向结束转向最终方向的时间点（以 0 到 1 之间的百分数表示）。默认值为 0.75。

• 如果 end_interpolation 小于 0 或大于 1，则会调整为默认值。

备注

1. 此命令立即返回，因此您可能希望在继续脚本之前wait(number:duration) 秒。
2. 当指定一个 “对象” 对象进行跳转时，最终方向将指向 “对象” 对象。
3. 当指定一个位置对象进行跳转时，最终方向将与初始方向相同。
4. 跳转到 object:getposition() 方法返回的位置与跳转到对象不同。这是因为返回的位置指的是对象的中心，因此您将跳转到该对象的中心。
5. 给定的位置应相对于通用参考系。因此，根据所使用的参考系，您必须先将位置转换为 “Universal”，然后才能在 goto 中使用它。
6. Celestia 中的位置分量 (X,Y,Z) 以光年百万分之一存储。因此，如果您定义了自己的公里或英里位置，则必须将这些位置进行转换。因此，您可以使用一个常量，该常量必须首先在您的脚本中初始化
   • 从公里到光年百万分之一，使用常量 uly_to_km = 9460730.4725808。
   • 从英里到光年百万分之一，使用常量 uly_to_mls = 5912956.5453630。
7. 接下来，您可以将公里或英里转换为光年百万分之一，如下所示
   • millionths_of_a_light_year = number:km / uly_to_km
   • millionths_of_a_light_year = number:miles / uly_to_mls

示例 1
跳转到指定对象。

mars = celestia:find("Sol/Mars")
celestia:select(mars)
obs = celestia:getobserver()
obs:goto(mars, 5.0)
celestia:print("We're on our way to Mars." , 5.0, -1, -1, 2, 4)
wait(5.0)

示例 2
跳转到指定位置，即地球和月球之间的一半。运行此示例后，按 [Shift + *] 键，以验证月球在观察者后视镜中的位置。

obs = celestia:getobserver()
-- Set frame of reference to "universal".
obs:setframe(celestia:newframe( "universal"))
-- Find the actual position of the Earth.
earth = celestia:find("Sol/Earth")
earthpos = earth:getposition()
-- Find the actual position of the Moon.
moon = celestia:find("Sol/Earth/Moon")
moonpos = moon:getposition()
-- Calculate new position halfway Earth - Moon.
newpos = earthpos + 0.5 * (moonpos - earthpos)
obs:goto(newpos, 3.0)
celestia:print("We're are going halfway Earth - Moon." , 5.0, -1, -1, 2, 4)
wait(3.0)
-- Follow and center Earth
obs:follow(earth)
obs:center(earth)
wait(2.0)

返回到观察者 方法索引。

goto (表)

1.3.2 observer:goto(table:parameters)

从具有初始方向的初始位置跳转到具有最终方向的最终位置。

使用此方法，可以执行许多不同类型的跳转。

参数

parameters

跳转的参数必须在表中给出。有效的表键是

• duration
  跳转所需的时间（以秒为单位）。默认值为 5 秒。
• from
  跳转开始的初始源位置。必须是 “位置” 对象。
• to
  跳转结束的最终目标位置。必须是 “位置” 对象。
• initialOrientation
  观察者的初始源方向。必须是 “旋转” 对象。
• finalOrientation
  观察者的最终目标方向。必须是 “旋转” 对象。
• startInterpolation
  跳转过程中，观察者应从初始方向开始转向最终方向的时间点（以 0 到 1 之间的百分数表示）。默认值为 0.25。
• endInterpolation
  跳转过程中，观察者应从初始方向结束转向最终方向的时间点（以 0 到 1 之间的百分数表示）。默认值为 0.75。
• accelTime
  指示在前往目标过程中，用于从初始位置加速和减速的时间比例（以 0 到 1 之间的百分比表示）。它还表示用于朝最终位置减速的时间。前往目标过程中的剩余时间用于匀速行驶。默认值为 0.25，最小值为 0.01，最大值为 0.5。

注意：请注意输入错误和 Celestia 对键的区分大小写。无法识别的键或类型错误的值将被直接忽略。

备注

1. 此命令立即返回，因此您可能希望在继续脚本之前wait(number:duration) 秒。
2. 如果想要从当前位置，以当前观察者的方向开始前往目标，可以使用 observer:getposition() 和 observer:getorientation() 方法分别获取当前位置和方向。
3. 给定的位置应相对于通用参考系。因此，根据所使用的参考系，您必须先将位置转换为 “Universal”，然后才能在 goto 中使用它。
4. Celestia 中的位置分量 (X,Y,Z) 以光年百万分之一存储。因此，如果您定义了自己的公里或英里位置，则必须将这些位置进行转换。因此，您可以使用一个常量，该常量必须首先在您的脚本中初始化
   • 从公里到光年百万分之一，使用常量 uly_to_km = 9460730.4725808。
   • 从英里到光年百万分之一，使用常量 uly_to_mls = 5912956.5453630。
5. 接下来，您可以将公里或英里转换为光年百万分之一，如下所示
   • millionths_of_a_light_year = number:km / uly_to_km
   • millionths_of_a_light_year = number:miles / uly_to_mls

示例
从火星中心出发，前往“宇宙”坐标系中 X 方向 20,000 公里的位置。

uly_to_km = 9460730.4725808
-- Set frame of reference to "universal"
obs = celestia:getobserver()
obs:setframe(celestia:newframe("universal"))
-- Find and select Mars
mars = celestia:find("Sol/Mars")
celestia:select(mars)
-- Obtain the actual position of Mars
now = celestia:gettime()
posmars = mars:getposition(now)
-- Define table and initialize table
parameters = { }
-- Number of seconds the goto should take
parameters.duration = 5.0
-- Obtain current observer position
parameters.from = obs:getposition()
-- Determine position to goto
parameters.to = celestia:newposition((posmars.x + (20000/uly_to_km)), posmars.y, posmars.z )
-- obtain current observer orientation
parameters.initialOrientation = obs:getorientation()
-- Determine observer orientation from position to goto, towards the position of Mars
parameters.finalOrientation = parameters.to:orientationto(posmars,celestia:newvector(0,1,0))
-- Start adjusting the observer orientation from the beginning of the goto
parameters.startInterpolation = 0.0
-- End adjusting the observer orientation at the end of the goto
parameters.endInterpolation = 1.0
-- Use 10% of the time to accelerate and 10% of the time to decelarate 
parameters.accelTime = 0.1
-- Perform the goto
obs:goto(parameters)
-- Finally follow Mars and wait until the goto has finished
obs:follow(mars)
wait(parameters.duration )

返回到观察者 方法索引。

gotolonglat

1.3.2 observer:gotolonglat(object:target [, number:longitude, number:latitude, number:distance, number:duration, vector:up-axis])

在指定时间内，前往目标对象表面经纬度坐标上方的位置，并指定距离和向上方向的轴。

参数

target

前往的目标对象。必须是“object”类型的对象。

longitude [可选]

目标对象表面经度坐标（以弧度表示）。默认值为 0。
西半球的经度为负数，东半球的经度为正数（不需要加“+”号）。

latitude [可选]

目标对象表面纬度坐标（以弧度表示）。默认值为 0。
南半球的纬度为负数，北半球的纬度为正数（不需要加“+”号）。

distance [可选]

距目标对象中心的距离（以公里表示）。默认值为目标对象半径的 5 倍。
特殊的距离值：

• 0（零）：前往目标对象中心。
• 目标对象的半径（公里）：前往目标对象表面。

duration [可选]

跳转所需的时间（以秒为单位）。默认值为 5 秒。

up-axis [可选]

定义向上方向的轴。必须是“vector”类型的对象。

• celestia:newvector(1,0,0) --> X 轴
• celestia:newvector(0,1,0) --> Y 轴是默认值
• celestia:newvector(0,0,1) --> Z 轴

备注

1. 经度和纬度以弧度（0 到 2*π）表示，不是度数（0 到 360）。180 度（半个圆周）等于 π 弧度 = 3.14159265 弧度 = math.pi 弧度（Lua）。可以使用以下方法将度数转换为弧度，反之亦然：
   • radians = math.rad( number:degrees ) = ( number:degrees / 180 * math.pi) = ( number:degrees / 180 * 3.14159265).
   • degrees = math.deg( number:radians ) = ( number:radians * 180 / math.pi) = ( number:radians * 180 / 3.14159265).
2. 可以使用 object:radius() 方法获取目标对象的半径（公里）。如果以公里表示的距离小于目标对象的半径（公里），则前往目标过程将在目标对象内部结束。
3. 此命令立即返回，因此您可能想要在脚本中继续执行之前，先使用 wait(number:duration) 方法等待指定时间（秒）。

示例
此示例选择地球，并将摄像机定位在距离地球表面 12,000 公里的美国华盛顿州西雅图上空。

earth = celestia:find("Sol/Earth")
celestia:select(earth)
obs = celestia:getobserver()
obs:synchronous(earth)
earthdistance = 12000 + earth:radius()
longitude = math.rad(-122.0)
latitude = math.rad(47.0)
obs:gotolonglat(earth, longitude, latitude, earthdistance, 5.0)
celestia:print("Traveling to Seattle, Washington, USA.", 5.0, -1, -1, 2, 4)
wait(5.0)
celestia:print("Hovering over Seattle, Washington, USA.", 5.0, -1, -1, 2, 4)
wait(5.0)

返回到观察者 方法索引。

gotolocation

observer:gotolocation(position:target [, number:duration])

在指定时间内，前往目标位置。

参数

target

前往的目标位置，在观察者的当前参考系中。必须是“position”类型的对象。

duration [可选]

跳转所需的时间（以秒为单位）。默认值为 5 秒。

备注

1. 此命令立即返回，因此您可能想要在脚本中继续执行之前，先使用 wait(number:duration) 方法等待指定时间（秒）。
2. 在此 observer:gotolocation() 方法中，位置是相对于此观察者的当前参考系而言的，而 observer:goto() 和 observer:goto(table) 方法使用的是宇宙参考系！
3. Celestia 中的位置分量 (X,Y,Z) 以光年百万分之一存储。因此，如果您定义了自己的公里或英里位置，则必须将这些位置进行转换。因此，您可以使用一个常量，该常量必须首先在您的脚本中初始化
   • 从公里到光年百万分之一，使用常量 uly_to_km = 9460730.4725808。
   • 从英里到光年百万分之一，使用常量 uly_to_mls = 5912956.5453630。
4. 接下来，您可以将公里或英里转换为光年百万分之一，如下所示
   • millionths_of_a_light_year = number:km / uly_to_km
   • millionths_of_a_light_year = number:miles / uly_to_mls

示例
前往位置：距地球中心 X = +7000 公里，Y = +9000 公里，Z = +11000 公里。

obs = celestia:getobserver()
-- Select and follow Earth (so the coordinate system
-- of the frame of reference is set to "ecliptic").
earth = celestia:find("Sol/Earth")
celestia:select(earth)
obs:follow(earth)
-- Convert km to millionths of a light year, using "uly_to_km".
uly_to_km = 9460730.4725808
newpos = celestia:newposition(7000/uly_to_km, 9000/uly_to_km, 11000/uly_to_km)
-- Goto target position.
obs:gotolocation(newpos, 5.0 )
wait(5.0)
-- You are at the right position now, but probably Earth is 
-- not visible yet. Center Earth to be sure to see our planet. 
obs:center(earth, 1.0)
wait(1.0)

返回到观察者 方法索引。

gotodistance

1.3.2 observer:gotodistance(object:target [, number:distance, number:duration, vector:up-axis])

在指定时间内，前往目标对象的指定距离，并指定向上方向的轴。

参数

target

前往的目标对象。必须是“object”类型的对象。

distance [可选]

距目标对象中心的距离（公里），表示停止的位置。默认值为 20000 公里。

duration [可选]

跳转所需的时间（以秒为单位）。默认值为 5 秒。

up-axis [可选]

定义向上方向的轴。必须是“vector”类型的对象。

• celestia:newvector(1,0,0) --> X 轴
• celestia:newvector(0,1,0) --> Y 轴是默认值
• celestia:newvector(0,0,1) --> Z 轴

备注

1. 可以使用 object:radius() 方法获取目标对象的半径（公里）。如果以公里表示的距离小于目标对象的半径（公里），则前往目标过程将在目标对象内部结束。
2. 此命令立即返回，因此您可能想要在脚本中继续执行之前，先使用 wait(number:duration) 方法等待指定时间（秒）。

示例
选择太阳，前往太阳，然后选择地球，前往地球。接着，花费 3.0 秒，将您的显示距离调整为距地球表面 90,000 公里。

sun = celestia:find("Sol")
celestia:select(sun)
obs = celestia:getobserver()
obs:goto(sun, 3.0)
wait(4.0)
earth = celestia:find("Sol/Earth")
celestia:select(earth)
obs:goto(earth, 3.0)
wait(4.0)
obs:gotodistance(earth, 90000+earth:radius(), 3.0)
wait(3.0)

返回到观察者 方法索引。

gotosurface

1.3.2 observer:gotosurface(object:target [, number:duration])

前往指定对象表面，并看向地平线。类似于按下键盘上的 [Ctrl+G] 键。

参数

target

要降落的对象。必须是“object”类型的对象。

duration [可选]

跳转所需的时间（以秒为单位）。默认值为 5 秒。

备注

1. 着陆位置将对应于您在前往目标开始之前悬停的物体表面经纬度坐标。
2. 前往目标完成后，您所看到的的地平线将对应于您在前往目标开始之前，屏幕上指向的方向（该方向即物体向上方向）。
3. 此命令立即返回，因此您可能想要在脚本中继续执行之前，先使用 wait(number:duration) 方法等待指定时间（秒）。

示例
前往火星表面。

obs = celestia:getobserver()
planet = celestia:find("Sol/Mars")
celestia:select(planet)
obs:goto(planet, 3.0)
wait(4.0)
obs:gotosurface(planet, 3.0)
wait(3.0)

返回到观察者 方法索引。

center

observer:center(object:target [, number:duration])

旋转观察者的视角，使目标对象位于屏幕中心。类似于按下键盘上的 [c] 键。

参数

target

要位于屏幕中心的物体。必须是“object”类型的对象。

duration [可选]

居中的持续时间（秒）。默认值为 5 秒。

示例： 首先将土星置于屏幕中心，然后直线前往该行星。

obs = celestia:getobserver()
planet = celestia:find("Sol/Saturn")
obs:center(planet, 3.0)
wait(3.0)
obs:goto(planet, 3.0)
wait(3.0)

返回到观察者 方法索引。

centerorbit

1.3.2 observer:centerorbit(object:target [, number:duration])

围绕当前参考系中用作参考的物体进行轨道运动，使目标在指定时间内位于中心。这类似于按下键盘上的 [Shift+C] 键。

参数

target

要位于中心的物体。必须是“object”类型的对象。

duration [可选]

居中的持续时间（秒）。默认值为 5 秒。

备注

1. 如果您在屏幕上有一个原始物体，然后使用 observer:center() 方法将新物体置于中心，您可能会失去对原始物体的视野，因为观察者会旋转以使新物体位于中心。使用此 observer:centerorbit() 方法，可以在不失去对原始物体的视野的情况下，使观察者旋转以使目标物体位于中心，原始物体用作当前参考系中的参考物体。
2. 如果当前参考系中用作参考的物体仍然位于屏幕中心，使用此方法可能会导致目标物体（完全或部分）消失在参考物体后面。
3. 如果当前参考系中用作参考的物体与目标物体相同，但不位于屏幕中心，使用此方法的结果将只是围绕该物体进行轨道运动（持续指定时间），其中观察者的方向相对于该物体保持不变。
4. 如果目标物体已经位于屏幕中心，使用此方法将不会发生任何情况。
5. 如果当前参考系为“宇宙”，使用此方法将不会发生任何情况。

示例

-- Goto and follow the Moon at specified distance
moon = celestia:find("Sol/Earth/Moon")
moonradius = moon:radius()
obs = celestia:getobserver()
obs:gotodistance(moon, 17500+moonradius, 3.0)
obs:follow(moon)
wait(3.0)
-- Rotate the observer a bit, so the Moon is not centered anymore
duration = 1.0
rotsteps = 25 * duration
rot = celestia:newrotation(celestia:newvector(0,1,0), math.rad(10)/rotsteps)
rotsteptime = duration/rotsteps
for i = 1, rotsteps do
   obs:rotate(rot)
   wait(rotsteptime)
end
-- Find and select Earth and center Earth on the screen, with the Moon still visible
earth = celestia:find("Sol/Earth")
celestia:select(earth)
obs:centerorbit(earth, 4.0)
wait(4.0)

返回到观察者 方法索引。

travelling

boolean observer:travelling()

返回一个布尔值，指示当前是否正在进行前往目标或居中操作。

• true 表示当前正在进行前往目标或居中操作
• false 表示当前没有进行前往目标或居中操作

备注

1. 此方法可以与 observer:cancelgoto() 方法结合使用，该方法可以停止当前正在进行的任何前往目标或居中操作。
2. 可以在 Lua 的“while”循环中使用此方法，以防止在仍有前往目标或居中操作正在进行的情况下继续执行其他方法。

示例
在 10 秒内前往月球，并在到达后显示闪烁的消息。

moon = celestia:find("Sol/Earth/Moon")
obs = celestia:getobserver()
obs:goto(moon, 10.0)
actual_travel = obs:travelling()
while actual_travel do
   actual_travel = obs:travelling()
   wait(0.0)
end
celestia:flash("Arrived at the Moon", 5.0)
wait(5.0)

返回到观察者 方法索引。

cancelgoto

1.3.2 observer:cancelgoto()

停止任何正在进行的 goto 或 center 命令。

备注

1. 与 CEL: CANCEL { } 命令不同，该命令也会取消任何 goto，此方法不会对当前参考系和对象跟踪生效。要完全模拟 CEL: CANCEL { } 命令，你还需要使用 observer:track(nil) 方法和 celestia:newframe("universal") 以及 observer:setframe() 方法。

示例
在 20 秒内前往月球，但在 5 秒后取消该 goto 命令。

moon = celestia:find("Sol/Earth/Moon")
obs = celestia:getobserver()
obs:goto(moon, 20.0)
wait(5.0)
actual_travel = obs:travelling()
if actual_travel then
   obs:cancelgoto()
   celestia:flash("GOTO aborted.",5.0)
   wait(5.0)
end

返回到观察者 方法索引。

跟随

observer:follow(object:target)

对目标对象激活跟随模式。

跟随与将参考系设置为 "ecliptical" 并将目标作为参考对象相同。

参数

target

要跟随的对象。必须是 "object" 对象。

备注

1. 随着对象在太空中移动，观察者也会随之移动。对象可以在其轴上旋转，这意味着经度将不断变化。观察者将保持与对象相同的距离和纬度。
2. X 轴指向远离太阳，朝向儒略 2000.0 春分点。Y 轴垂直于黄道，正 Y 指向北。Z 轴完成右手坐标系。

示例
选择火星，激活跟随模式，然后前往火星。

mars = celestia:find("Sol/Mars")
celestia:select(mars)
obs = celestia:getobserver()
obs:follow(mars)
obs:goto(mars, 2.0)
wait(2.0)

返回到观察者 方法索引。

同步

observer:synchronous(object:target)

对目标对象激活同步模式。

同步模式与将参考系设置为 "planetographic"（也称为 "geographic"），并将目标作为参考对象相同。

参数

target

要与之同步的对象。必须是 "object" 对象。

备注

1. 观察者保持在参考对象上方的静止或地球同步轨道上。当对象在其轴上旋转时，观察者将保持与对象相同的距离、经度和纬度，就好像它与对象相连一样。
2. Celestia 坐标系的原点是参考对象的中心。
3. 在地理坐标系中，坐标轴随着所选对象一起旋转。Y 轴是旋转轴，逆时针方向，因此对于顺行旋转体（如地球）它指向北，对于逆行旋转体（如金星）它指向南。X 轴从对象的中心指向其零经度子午线与赤道的交点。Z 轴（与 XY 平面成直角）完成右手坐标系。

示例
选择地球并激活同步模式。

earth = celestia:find("Sol/Earth")
celestia:select(earth)
obs = celestia:getobserver()
obs:synchronous(earth)

返回到观察者 方法索引。

追逐

observer:chase(object:target)

对目标对象激活追逐模式。

追逐模式与将参考系设置为 "chase" 并将目标作为参考对象相同。

参数

target

要追逐的对象。必须是 "object" 对象。

备注

1. 在追逐模式下，观察者的位置相对于目标运动方向保持固定，观察者的方向相对于目标运动方向保持不变。
2. Celestia 坐标系的原点是参考对象的中心。
3. 此坐标系类似于 "lock"，不同的是，Z 轴指向相对于目标对象父体（行星的太阳，卫星的行星）的运动方向。

示例
选择月球，激活追逐模式，然后前往月球。

moon = celestia:find("Sol/Earth/Moon")
celestia:select(moon)
obs = celestia:getobserver()
obs:chase(moon)
obs:goto(moon, 2.0)
wait(2.0)

返回到观察者 方法索引。

锁定

observer:lock(object:target)

激活从当前参考对象到目标对象的轴的锁定模式。

锁定模式与将参考系设置为 "lock"，并将目标作为目标对象和当前参考对象相同。

参数

target

要与当前参考对象锁定的对象。必须是 "object" 对象。

备注

1. 在锁定模式下，观察者的位置相对于参考对象和目标对象之间的直线保持固定。当目标对象相对于参考对象移动（相对而言）时，观察者也会随之移动。观察者到参考对象的距离保持不变，观察者到目标对象的距离可能会变化。
2. Celestia 坐标系的原点是参考对象的中心。
3. Z 轴从参考对象指向目标对象。Y 轴位于由 Z 轴和参考对象旋转轴定义的平面上，与 Z 轴成直角。X 轴完成右手坐标系。
4. 仅在激活锁定模式之前选择一个对象，不会使该对象成为参考对象。要使一个对象成为参考对象，请先使用 observer:follow() 或 observer:synchronous() 或 observer:chase() 方法，然后再激活锁定模式。
5. 如果参考对象与目标对象相同，则在太阳系中，中央恒星将被设置为参考对象。
6. 如果太阳系中的中央恒星既是参考对象又是目标对象，则使用此 observer:lock() 方法将没有任何效果。
7. 如果在使用此 observer:lock() 方法之前激活了 "universal" 参考系（因此没有可用的参考对象），则使用此方法将没有任何效果。

示例
相对于地球保持位置，并使月球和地球之间的直线在视野中保持固定。（请注意，由于月球轨道偏心率，相对于月球的位置将会变化）。

-- Goto and follow the Moon at specified distance
moon = celestia:find("Sol/Earth/Moon")
moonradius = moon:radius()
obs = celestia:getobserver()
obs:gotodistance(moon, 45000+moonradius, 3.0)
obs:follow(moon)
wait(3.0)
-- Rotate the observer a bit, so the Moon is not centered anymore
duration = 1.0
rotsteps = 25 * duration
rot = celestia:newrotation(celestia:newvector(0,1,0), math.rad(10)/rotsteps)
rotsteptime = duration/rotsteps
for i = 1, rotsteps do
   obs:rotate(rot)
   wait(rotsteptime)
end
-- Find and select Earth and center Earth on the screen, with the Moon still visible
earth = celestia:find("Sol/Earth")
celestia:select(earth)
obs:centerorbit(earth, 4.0)
wait(4.0)
-- Make Earth the current reference object
obs:follow(earth)
-- Both Moon and Earth are in view now.
-- Activate lock mode and accelerate time.
obs:lock(moon)
celestia:settimescale(21600)

返回到观察者 方法索引。

跟踪

observer:track(object:target)

对对象设置跟踪，即始终保持目标对象在它在太空中移动时保持在屏幕中央。

参数

target

要跟踪的对象。必须是 "object" 对象。

备注

1. 即使选择了另一个对象，跟踪也会保留在对象上。在你试图查看另一个对象之前，你必须取消对第一个对象的跟踪。
2. 要停止跟踪对象，请使用 observer:track(nil)。

示例
释放对任何当前选定对象的控制，然后选择地球并前往地球并跟踪它。地球将以它在太空中实际移动的速度开始远离你，但 Celestia 会跟踪地球，使其保持在显示器中央。时间将加速 1000 倍。

obs = celestia:getobserver()
obs:cancelgoto()
obs:track(nil)
obs:setframe(celestia:newframe("universal"))
earth = celestia:find("Sol/Earth")
celestia:select(earth)
distance = 7 * earth:radius()
obs:gotodistance(earth, distance, 3.0 )
wait (5.0)
obs:track(earth)
celestia:settimescale(1000)

返回到观察者 方法索引。

获取位置

position observer:getposition()

返回此观察者在通用坐标系中的当前位置，作为 "position" 对象。

备注

1. Celestia 中的位置分量 (X,Y,Z) 以光年百万分之一存储。因此，如果您定义了自己的公里或英里位置，则必须将这些位置进行转换。因此，您可以使用一个常量，该常量必须首先在您的脚本中初始化
   • 从公里到光年百万分之一，使用常量 uly_to_km = 9460730.4725808。
   • 从英里到光年百万分之一，使用常量 uly_to_mls = 5912956.5453630。
2. 接下来，您可以将公里或英里转换为光年百万分之一，如下所示
   • millionths_of_a_light_year = number:km / uly_to_km
   • millionths_of_a_light_year = number:miles / uly_to_mls
3. CELX "position" 对象包含太空中一个点的精确坐标。位置相对于坐标系，可能需要在进一步使用之前转换为或从通用坐标系转换。
4. 可以在 CELX "position" 对象上使用 position 方法。"Position" 对象也可以在其他方法中使用，这些方法需要 "position" 对象作为参数。

示例

obs = celestia:getobserver()
actual_obspos = obs:getposition()
celestia:print("Actual observer position:\nX = " .. actual_obspos.x .. 
               "\nY = " .. actual_obspos.y .. "\nZ = " ..  actual_obspos.z, 15, -1, -1, 1, 6)
wait(15.0)

返回到观察者 方法索引。

设置位置

observer:setposition(position:pos)

设置此观察者的新位置。

参数

pos

此观察者在通用坐标系中的新位置。必须是 "position" 对象。

备注

1. Celestia 中的位置分量 (X,Y,Z) 以光年百万分之一存储。因此，如果您定义了自己的公里或英里位置，则必须将这些位置进行转换。因此，您可以使用一个常量，该常量必须首先在您的脚本中初始化
   • 从公里到光年百万分之一，使用常量 uly_to_km = 9460730.4725808。
   • 从英里到光年百万分之一，使用常量 uly_to_mls = 5912956.5453630。
2. 接下来，您可以将公里或英里转换为光年百万分之一，如下所示
   • millionths_of_a_light_year = number:km / uly_to_km
   • millionths_of_a_light_year = number:miles / uly_to_mls

示例
设置新的观察者位置，位于地球和月球之间的一半位置。运行此示例后，按 [Shift + *] 键，以验证月球在观察者后视镜中的位置。

obs = celestia:getobserver()
-- Set frame of reference to "universal".
obs:setframe(celestia:newframe( "universal"))
-- Find the actual position of the Earth.
earth = celestia:find("Sol/Earth")
earthpos = earth:getposition()
-- Find the actual position of the Moon.
moonpos = celestia:find("Sol/Earth/Moon"):getposition()
-- Calculate new position halfway Earth - Moon.
newpos = earthpos + 0.5 * (moonpos - earthpos)
-- Set new observer position and follow/center Earth
obs:setposition(newpos)
obs:follow(earth)
obs:center(earth, 0.0)
wait(0.0)

返回到观察者 方法索引。

获取方向

rotation observer:getorientation()

返回此观察者的当前方向，作为 "rotation" 对象。

备注

1. CELX "rotation" 对象在内部是一个四元数，它是数学上描述三维旋转的一种可能性（即它可以转换为旋转矩阵）。旋转也可以用来描述物体的方向或观察者的方向（即观察者看向哪里，以及“向上”在哪里）。
2. 可以在 CELX "rotation" 对象上使用 rotation 方法。"Rotation" 对象也可以在其他方法中使用，这些方法需要 "rotation" 对象作为参数。

示例

obs = celestia:getobserver()
actual_obsrot = obs:getorientation()

返回到观察者 方法索引。

设置方向

observer:setorientation(rotation:rot)

设置此观察者的新方向。

参数

rot

此观察者的新方向。必须是 "rotation" 对象。

示例
将新的观察者位置设置为地球和月球的中点，然后将观察者的方向交替指向地球和月球。

obs = celestia:getobserver()
-- Set frame of reference to "universal".
obs:setframe(celestia:newframe("universal"))
-- Find the actual position of the Earth.
earth = celestia:find("Sol/Earth")
earthpos = earth:getposition()
-- Find the actual position of the Moon.
moonpos = celestia:find("Sol/Earth/Moon"):getposition()
-- Calculate new position halfway Earth - Moon.
newpos = earthpos + 0.5 * (moonpos - earthpos)
obs:setposition(newpos)
-- Follow Earth
obs:follow(earth)
-- Observer orientation to look from newpos towards Earth.
rot1 = newpos:orientationto(earthpos, celestia:newvector(0,1,0))
-- Observer orientation to look from newpos towards the Moon.
rot2 = newpos:orientationto(moonpos, celestia:newvector(0,1,0))
-- Alternately switch the observer orientation.
for i = 1, 5 do
   obs:setorientation(rot1)
   wait(1.0)
   obs:setorientation(rot2)
   wait(1.0)
end

返回到观察者 方法索引。

旋转

observer:rotate(rotation:rot)

根据给定的旋转，旋转观察者。

参数

rot

要用于当前观察者方向的旋转。必须是“rotation”对象。

备注

1. 此方法立即设置新的观察者方向。为了更接近模拟 CEL: ROTATE 命令，并让观察者在一段时间内旋转，可以在 Lua “for” 或 “while” 控制结构中使用此 observer:rotate() 方法将旋转角度分解成多个较小的旋转角度，然后快速依次处理这些角度（请参阅下一条注释）。
2. 在 Lua “for” 控制结构中使用此 observer:rotate() 方法时（请参阅示例-1），旋转周期将比 number:duration 秒多出一小段时间（取决于您的计算机速度），但沿指定轴的总旋转角度将完全正确。这是因为在生成的循环中，执行命令也会占用一些额外的计算机时间。对于速度较慢的计算机，您可以减少每秒的步数，但这也会导致场景变得更加卡顿。
3. 也可以在 Lua “while” 控制结构中使用此 observer:rotate() 方法（请参阅示例-2）。在这种情况下，旋转周期可以精确地设置为 number:duration 秒，但沿指定轴的总旋转角度将不会完全正确。同样取决于您的计算机速度，您需要对 “while” 控制结构中每个序列的步长或等待时间进行猜测，才能尽可能接近目标总旋转角度。

示例 1
选择、跟踪并居中地球，然后将观察者在大约 5 秒内沿地球的 Z 轴向右旋转精确 90 度。

-- Find, select, follow and center Earth first.
earth = celestia:find("Sol/Earth")
celestia:select(earth)
obs = celestia:getobserver()
obs:follow(earth)
obs:center(earth, 1.0)
wait(1.0)
-- Rotate the observer during about 5 seconds over exactly 90 degrees along the Z axis
duration = 5.0
axis_vector = celestia:newvector(0,0,1)
rotationangle = math.rad(90)
obs = celestia:getobserver()
-- Split up the rotation in 50 steps per second.
-- The factor 0.75 is an estimate and may depend on the speed of your computer.
rotsteps = 50 * duration
rotsteptime = 0.75*duration/rotsteps
-- Create new rotation object of split up rotation angle over the specified axis.
rot = celestia:newrotation(axis_vector, rotationangle/rotsteps)
-- Actually execute the rotation.
for i = 1, rotsteps do
   obs:rotate(rot)
   wait(rotsteptime)
end

示例 2
选择、跟踪并居中地球，然后将观察者在精确 5 秒内沿地球的 Z 轴向右旋转大约 90 度。

-- Find, select, follow and center Earth first.
earth = celestia:find("Sol/Earth")
celestia:select(earth)
obs = celestia:getobserver()
obs:follow(earth)
obs:center(earth, 1.0)
wait(1.0)
-- Rotate the observer during exactly 5 seconds over about 90 degrees along the Z axis
duration = 5.0
axis_vector = celestia:newvector(0,0,1)
rotationangle = math.rad(90)
obs = celestia:getobserver()
-- Split up the rotation in 50 steps per second.
-- The factor 0.75 is an estimate and may depend on the speed of your computer.
rotsteps = 50 * duration
rotsteptime = 0.75*duration/rotsteps
-- Create new rotation object of split up rotation angle over the specified axis.
rot = celestia:newrotation(axis_vector, rotationangle / rotsteps)
-- Get the elapsed time in seconds since the script has been started and store in "t0". 
t0= celestia:getscripttime()
-- Actually execute the rotation.
while celestia:getscripttime() <= t0 + duration do
   obs:rotate(rot)
   wait(rotsteptime)
end

返回到观察者 方法索引。

lookat

observer:lookat([position:from,] position:to, vector:up)

根据规范设置观察者的方向，以从 position:from 处看向 position:to，并让 vector:up 指向上方。

参数

from [可选]

看向位置 to 的点。必须是“position”对象。
如果未提供，则使用当前位置。

to

从位置 from 处看向的点。必须是“position”对象。

up

指向当前视图中 up 方向的向量。必须是“vector”对象。
不能与 from --> to 的轴平行。

备注

1. 将观察者的方向设置为从 position:from 处看向 position:to 并不意味着观察者也位于 position:from 处。此方法仅设置观察者方向，而不设置观察者位置。

示例
转到地球将在 1 天内到达的空间位置。从该位置看向地球，并观察地球如何向你靠近（时间加速 3600 倍）。及时躲开…

-- Find and select Earth
earth = celestia:find("Sol/Earth")
celestia:select(earth)
obs = celestia:getobserver()
-- Set frame of reference to "universal".
obs:setframe(celestia:newframe("universal"))
-- Determine the new observer position and the position of Earth
now = celestia:gettime()
newpos = earth:getposition(now+1)
posearth = earth:getposition(now)
obs:goto(newpos,0.0)
wait(0.0)
-- Look at Earth and see how it comes towards you
upvec = celestia:newvector(0,1,0)
obs:lookat(newpos, posearth, upvec)
celestia:settimescale(3600)

返回到观察者 方法索引。

gettime

number observer:gettime()

将此观察者的时间作为 TDB（质心动力时间）儒略日返回。

旧版本的 Celestia 使用 UTC（协调世界时）来计算时间和位置。
从版本 1.5.0 开始，虽然 Celestia 仍然在屏幕上显示 UTC，
但它在内部使用 TDB 时间刻度来执行其他所有操作，因此对于 CELX 脚本来说， !!!

备注

1. 此方法不同于 celestia:gettime() 方法，因为在多视图场景中，模拟时间在可用观察者之间可能会有所不同。此方法返回活动视图观察者的时间。有关不同视图（观察者）之间时间同步的更多信息，请查看 1.6.1 celestia:synchronizetime() 和 1.6.1 celestia:istimesynchronized() 方法。
2. TDB 时间刻度与更熟悉的 UTC 略有不同。通过使用 TDB，Celestia 可以更准确地放置物体。截至 2008 年 1 月 1 日，两者之间的差异约为 65 秒。有关更多信息，请参阅 Celestia/Time_Scales。
3. 要进行 UTC 和 TDB 时间之间的转换，您可以使用 1.5.0 celestia:utctotdb() 和 1.5.0 celestia:tdbtoutc() 方法。
4. 要进行普通日历日期和儒略日之间的转换，您可以使用 celestia:tojulianday() 和 celestia:fromjulianday() 方法。

示例
获取活动视图观察者的 TDB 时间，并将其转换为 UTC 日历日期/时间。可以通过将 print 语句的结果与屏幕右上角显示的 UTC 日期/时间进行比较来检查这一点。

celestia:settimescale(0)
obs = celestia:getobserver()
actual_observer_tdbtime = obs:gettime()
ut = celestia:tdbtoutc(actual_observer_tdbtime)
celestia:print("Date/time: " .. ut.year .. " " .. ut.month .. " " .. ut.day .. " "
                .. ut.hour .. " " .. ut.minute .. " " .. ut.seconds, 10.0, -1, -1, 2, 4) 
wait(10.0)

返回到观察者 方法索引。

getspeed

1.3.2 number observer:getspeed()

将此观察者的当前速度以百万分之一光年/秒的形式返回一个数字。

备注

1. 可以使用 observer:setspeed() 方法设置此观察者的速度。
2. 当您想要将获得的速度转换为 km/s 或 miles/s 时，可以使用一个常量，该常量必须首先在您的脚本中进行初始化
   • 从百万分之一光年转换为 km，使用常量 uly_to_km = 9460730.4725808。
   • 从百万分之一光年转换为 miles，使用常量 uly_to_mls = 5912956.5453630。
3. 接下来，您可以将百万分之一光年转换为 km 或 miles，如下所示
   • km/s = number:millionths_of_a_light_year/s * uly_to_km
   • miles/s = number:millionths_of_a_light_year/s * uly_to_mls

示例
获取此观察者的实际速度。要检查此示例的工作原理，您首先可以多次按下键盘上的 [A] 键，将观察者的速度设置为特定值，该值将在屏幕左下角显示（如果未显示，请按下键盘上的 [V] 键）。

uly_to_km = 9460730.4725808
obs = celestia:getobserver()
actual_obsspeed = obs:getspeed() * uly_to_km
celestia:print("Actual observer speed: " .. actual_obsspeed .. " km/s.", 10.0, -1, -1, 2, 4)
wait(10.0)

返回到观察者 方法索引。

setspeed

1.3.2 observer:setspeed(number:speed)

设置此观察者的速度。

参数

speed

此观察者的速度，以百万分之一光年/秒为单位。必须是数字。

备注

1. 可以使用 observer:getspeed() 方法获取此观察者的实际速度。
2. 当您拥有以 km/s 或 miles/s 为单位定义的速度时，您需要将此速度转换为百万分之一光年/秒。为此，您可以使用一个常量，该常量必须首先在您的脚本中进行初始化
   • 从 km/s 转换为百万分之一光年/s，使用常量 uly_to_km = 9460730.4725808。
   • 从 miles/s 转换为百万分之一光年/s，使用常量 uly_to_mls = 5912956.5453630。
3. 接下来，您可以将 km/s 或 miles/s 转换为百万分之一光年/s，如下所示
   • millionths_of_a_light_year/s = number:km/s / uly_to_km
   • millionths_of_a_light_year/s= number:miles/s / uly_to_mls

示例
将此观察者的速度设置为 150 km/s。观察者的速度将在屏幕左下角显示（如果未显示，请按下键盘上的 [V] 键）。

uly_to_km = 9460730.4725808
obs = celestia:getobserver()
obs:setspeed(150/uly_to_km)

返回到观察者 方法索引。

getsurface

string observer:getsurface()

返回一个字符串，描述当前使用的表面。这可能是“知识的极限”，或者可能是备用表面的名称。

备注

1. 当使用“正常”表面时，将返回空字符串 ""。

示例

obs = celestia:getobserver()
actual_surface = obs:getsurface()
celestia:print("Actual surface: " .. actual_surface, 10.0, -1, -1, 2, 4)
wait(10.0)

返回到观察者 方法索引。

setsurface

observer:setsurface(string:name)

为与指定表面名称相关的物体设置此观察者要显示的备用表面纹理。

参数

name

要使用的表面的名称。必须是字符串。
名称必须与solarsys.ssc 文件的AltSurface条目中定义的备用表面名称一致。它不是纹理文件本身的名称。
注意: 当必须设置 'Normal' 表面时，请使用空字符串 ""。

备注

1. 例如，如果您想为地球创建一个名为 "Earth-2" 的备用表面纹理，并且它的相关纹理文件名是 earth2.jpg，您将在 ' "Earth" "Sol" ' 条目的结束大括号之后，将以下条目添加到 solarsys.ssc 文件中。"Earth-2" 在下面的代码中是在 observer:setsurface() 方法中指定的表面名称。

AltSurface "Earth-2" "Sol/Earth"
{
  Texture "earth2.jpg"
}

示例

-- Set surface to 'limit of knowledge'
celestia:getobserver():setsurface("limit of knowledge")

-- Set surface to 'Normal'
celestia:getobserver():setsurface("")

-- Set surface to 'Earth-2' according the code in 'Notes'.
celestia:getobserver():setsurface("Earth-2")

返回到观察者 方法索引。

getlocationflags

1.3.2 表格 observer:getlocationflags()

返回一个包含所有已知位置标志的表格（参见observer:setlocationflags() 方法）作为键，以及一个布尔值作为值，指示特定位置标志是启用还是禁用。

备注

1. 此方法特别有用，可以在脚本开始时保存所有位置标志，以便使用 celestia_cleanup_callback() 函数在脚本结束或脚本终止时重置这些值。

示例

obs = celestia:getobserver()
actual_locationflags = obs:getlocationflags()

返回到观察者 方法索引。

setlocationflags

1.3.2 observer:setlocationflags(table:locationflags)

使用 celestia:setlabelflags() 或 celestia:showlabel() 方法打开位置时，启用或禁用特定位置类型的标记。

参数

locationflags

一个包含位置标志作为键，以及每个键的布尔值作为值的表格。每个位置标志必须是以下之一：

• city
• observatory
• landingsite
• crater
• vallis
• mons
• planum
• chasma
• patera
• mare
• rupes
• tessera
• regio
• chaos
• terra
• volcano
• astrum
• corona
• dorsum
• fossa
• catena
• mensa
• rima
• undae
• tholus
• reticulum
• planitia
• linea
• fluctus
• farrum
• insula
• other

备注

1. 可以使用 observer:getlocationflags() 方法获取特定位置类型标记的当前设置。
2. 可以使用 celestia:setminfeaturesize() 方法设置要标记的位置的最小尺寸。
3. 在 Celestia Motherlode 上，您可以找到并下载 Bob Hegwood 为太阳系行星制作的不同巡回脚本。当您在计算机上安装并运行这些脚本时，您将了解有关特定位置类型的含义的更多信息。

示例
启用所有位置类型的标记。

-- create and initialize table
table = {}
table.city = true
table.observatory = true
table.landingsite = true
table.crater = true
table.vallis = true
table.mons = true
table.planum = true
table.chasma = true
table.patera = true
table.mare = true
table.rupes = true
table.tessera = true
table.regio = true
table.chaos = true
table.terra = true
table.astrum = true
table.corona = true
table.dorsum = true
table.fossa = true
table.catena = true
table.mensa = true
table.rima = true
table.undae = true
table.reticulum = true
table.planitia = true
table.linea = true
table.fluctus = true
table.farrum = true
table.other = true
obs = celestia:getobserver()
obs:setlocationflags(table)
celestia:setlabelflags{locations = true}

或更短

-- note the curly braces
obs = celestia:getobserver()
obs:setlocationflags{city = true, observatory = true, landingsite = true, crater = true,
                     vallis = true, mons = true, planum = true, chasma = true, patera = true,
                     mare = true, rupes = true, tessera = true, regio = true, chaos = true,
                     terra = true, astrum = true, corona = true, dorsum = true, fossa = true,
                     catena = true, mensa = true, rima = true, undae = true, reticulum = true,
                     planitia = true, linea = true, fluctus = true, farrum = true, other = true}
celestia:setlabelflags{locations = true}

或更短

obs = celestia:getobserver()
table = obs:getlocationflags()
for key, value in pairs(table) do 
   table[key] = true 
end
obs:setlocationflags(table)
celestia:setlabelflags{locations = true}

返回到观察者 方法索引。

getfov

数字 observer:getfov()

以弧度为单位返回此观察者的当前视野 (FOV) 值。

备注

1. Celestia 以像素为单位相对于显示窗口的大小计算 FOV 值，但也可以使用 observer:setfov() 方法设置。
2. FOV 值以度数°分'秒" 的格式显示在屏幕右下角。(如果未显示任何值，请按键盘上的 [V] 键)。
3. CELX 中的角度以弧度而不是度数定义。180 度（半圆）等于 π 弧度 = 3.14159265 弧度 = math.pi 弧度 (LUA)。您可以按照以下步骤将度数转换为弧度，反之亦然。
   • radians = math.rad( number:degrees ) = ( number:degrees / 180 * math.pi) = ( number:degrees / 180 * 3.14159265).
   • degrees = math.deg( number:radians ) = ( number:radians * 180 / math.pi) = ( number:radians * 180 / 3.14159265).
4. 请注意，屏幕上显示的分钟部分和秒部分不是从 0 到 100，而是从 0 到 60。
   要从度数°分'秒" 转换为弧度，您首先需要将分钟和秒转换为十进制度数，反之亦然。

示例
获取并打印实际的 FOV 值，以度数°分'秒" 为单位。将其与屏幕右下角的 FOV 值进行比较。

obs = celestia:getobserver()
actual_fov = obs:getfov()
degrees = math.deg(actual_fov)
-- Determine whole number of degrees
degrees_d = math.floor(degrees)
-- Determine whole number of minutes
degrees = (degrees - degrees_d) * 60
degrees_m = math.floor(degrees)
-- Determine number of seconds
degrees_s = (degrees - degrees_m) * 60
celestia:print("Actual FOV value is: " .. degrees_d .. " degrees " ..
                degrees_m .. " minutes " .. degrees_s .. " seconds.", 10.0, -1, -1, 2, 4)
wait(10.0)

返回到观察者 方法索引。

setfov

observer:setfov(数字:fov)

以弧度为单位设置此观察者的视野 (FOV) 值。

参数

fov

以弧度为单位的新 FOV 值。必须是数字。

备注

1. Celestia 以像素为单位相对于显示窗口的大小计算 FOV 值。可以使用 observer:getfov() 方法获取此观察者的当前 FOV 值。
2. FOV 值以度数°分'秒" 的格式显示在屏幕右下角。(如果未显示任何值，请按键盘上的 [V] 键)。
3. CELX 中的角度以弧度而不是度数定义。180 度（半圆）等于 π 弧度 = 3.14159265 弧度 = math.pi 弧度 (LUA)。您可以按照以下步骤将度数转换为弧度，反之亦然。
   • radians = math.rad( number:degrees ) = ( number:degrees / 180 * math.pi) = ( number:degrees / 180 * 3.14159265).
   • degrees = math.deg( number:radians ) = ( number:radians * 180 / math.pi) = ( number:radians * 180 / 3.14159265).
4. 请注意，屏幕上显示的分钟部分和秒部分不是从 0 到 100，而是从 0 到 60。
   要从度数°分'秒" 转换为弧度，您首先需要将分钟和秒转换为十进制度数，反之亦然。

示例
将此观察者的新 FOV 值设置为 25°45'15"。

degrees_d = 25
degrees_m = 45
degrees_s = 15
-- Convert number of seconds to decimal minutes
degrees = degrees_s / 60
-- Convert number of minutes to decimal degrees
degrees = (degrees_m + degrees) / 60
degrees = degrees_d + degrees
radians = math.rad(degrees)
obs = celestia:getobserver()
obs:setfov(radians)

返回到观察者 方法索引。

getframe

框架 observer:getframe()

在 CELX "框架" 对象中返回此观察者的参考框架。

备注

1. 可以使用 observer:setframe() 方法设置此观察者的新参考框架。
2. CELX 参考 "框架" 是一个原点和一组轴，定义了用于天体轨迹和方向的坐标系。原点是目录文件中定义的另一个天体。有多种方法可以设置坐标系轴。
3. 可以使用 框架 方法在 CELX "框架" 对象上。本节还提供了有关使用参考框架的更多信息。"框架" 对象也可以在其他方法中使用，这些方法需要 "框架" 对象作为参数。

示例

obs = celestia:getobserver()
actual_frame = obs:getframe()

返回到观察者 方法索引。

setframe

observer:setframe(框架:f)

设置此观察者的新参考框架。

参数

f

此观察者的新参考框架。必须是 "框架" 对象。

备注

1. 可以使用 observer:getframe() 方法获取此观察者的当前参考框架。
2. 可以使用 celestia:newframe() 方法创建一个新的参考框架作为 "框架" 对象。

示例 1
告诉 Celestia 将活动坐标系设置为 UNIVERSAL

frame = celestia:newframe("universal")
obs = celestia:getobserver()
obs:setframe(frame)

示例 2
以下示例选择月球，然后将活动坐标系设置为 CHASE 并前往月球。

moon = celestia:find("Sol/Earth/Moon")
celestia:select(moon)
frame = celestia:newframe("chase", moon)
obs = celestia:getobserver()
obs:setframe(frame)
obs:goto(moon, 2.0)
wait(2.0)

示例-3
告诉 Celestia 将活动坐标系设置为锁定地球和太阳。此示例将保持您相对于地球中心的方位，并在时间推移时将太阳 (Sol) 和地球保持在视野中。在运行此示例之前，请确保地球和太阳都在观察者的视野中。

earth = celestia:find("Sol/Earth")
celestia:select(earth)
sun = celestia:find("Sol")
frame = celestia:newframe("lock", earth, sun)
obs = celestia:getobserver()
obs:setframe(frame)
celestia:settimescale(50000)

返回到观察者 方法索引。

splitview

1.3.2 observer:splitview(字符串:splitdirection [, 数字:splitpos])

拆分此观察者的视图。

参数

splitdirection

用于确定屏幕必须沿哪个方向拆分的字符串。必须是

• "H" 表示水平拆分。
• "V" 表示垂直拆分。

splitpos [可选]

以 0（左/下）到 1（右/上）之间的百分比数字表示在何处拆分活动视图。默认值为 0.5（在中间）。

• 如果 splitpos 小于 0.1，则 splitpos 将调整为 0.1。
• 如果 splitpos 大于 0.9，则 splitpos 将调整为 0.9。

备注

1. 在使用此 observer:splitview() 方法之后，可以使用 celestia:getobservers() 方法获取每个视图的 "观察者" 对象。

示例
将实际视图在中间垂直拆分。左侧转到金星，右侧转到火星，并在 10 秒后再次恢复单视图。

obs = celestia:getobserver()
obs:splitview("V", 0.5)
observers = celestia:getobservers()
venus = celestia:find("Sol/Venus")
observers[1]:gotodistance(venus, 50000)
mars = celestia:find("Sol/Mars")
observers[2]:gotodistance(mars, 30000)
wait(10.0)
obs:singleview()

返回到观察者 方法索引。

deleteview

1.3.2 observer:deleteview()

删除此观察者的视图。

在使用此方法后，观察者将变得无效。

备注

1. 只有在至少存在一个 Mulitiview 时，使用此方法才有意义。此方法对单视图观察者没有影响。

示例
将实际视图在中间垂直拆分。左侧转到金星，右侧转到火星，并在 10 秒后删除金星上的视图。

obs = celestia:getobserver()
obs:splitview("V", 0.5)
observers = celestia:getobservers()
venus = celestia:find("Sol/Venus")
observers[1]:gotodistance(venus, 50000)
mars = celestia:find("Sol/Mars")
observers[2]:gotodistance(mars, 30000)
wait(10.0)
observers[1]:deleteview()

返回到观察者 方法索引。

singleview

1.3.2 observer:singleview()

使此观察者的视图成为唯一的视图。

所有其他观察者视图将被删除，并立即变得无效。

备注

1. 此方法在 celestia_cleanup_callback() 函数中也很有用，因此单视图将始终在脚本结束或脚本终止时恢复。

示例
创建 4 个观察者的多视图，并在几秒钟后，将第 4 个观察者设为唯一的视图。

obs = celestia:getobserver()
obs:splitview("V", 0.5)
observers = celestia:getobservers()
observers[1]:splitview("H", 0.5)
observers[2]:splitview("H", 0.5)
observers = celestia:getobservers()
mercury = celestia:find("Sol/Mercury")
observers[1]:gotodistance(mercury, 20000)
venus = celestia:find("Sol/Venus")
observers[2]:gotodistance(venus, 50000)
mars = celestia:find("Sol/Mars")
observers[3]:gotodistance(mars, 30000)
io = celestia:find("Sol/Jupiter/Io")
observers[4]:gotodistance(io, 15000)
celestia:print("Which view does not belong in this scene?", 10.0, -1, -1, 2, 4)
wait(10.0)
observers[4]:singleview()
celestia:print("This view, because Io is a moon of\n" ..
               "Jupiter, instead of a planet.", 10.0, -1, -1, 2, 4)
wait(10.0)

返回到观察者 方法索引。

isvalid

1.3.2 布尔值 observer:isvalid()

返回一个布尔值，指示观察者是否仍然有效。

• 如果此观察者仍然有效，则为 true。
• 如果此观察者不再有效，则为 false。

示例
创建多视图，然后删除一些视图，并确定哪些观察者仍然有效。

obs = celestia:getobserver()
obs:splitview("V", 0.5)
observers = celestia:getobservers()
observers[1]:splitview("H", 0.5)
observers[2]:splitview("H", 0.5)
observers = celestia:getobservers()
mercury = celestia:find("Sol/Mercury")
observers[3]:gotodistance(mercury, 20000)
venus = celestia:find("Sol/Venus")
observers[1]:gotodistance(venus, 50000)
earth = celestia:find("Sol/Earth")
observers[4]:gotodistance(earth, 50000)
mars = celestia:find("Sol/Mars")
observers[2]:gotodistance(mars, 30000)
celestia:print("The 4 inner planets of our Solar System.", 10.0, -1, -1, 2, 4)
wait(10.0)
observers[4]:singleview()
celestia:print("Back to our own planet", 3.0, -1, -1, 2, 4)
wait(3.0)
valid = { }
for key, value in pairs(observers) do 
   valid[key] = observers[key]:isvalid() 
   if valid[key] then
      celestia:print("Observer " .. key .. " is valid.", 3.0, -1, -1, 2, 4)
   else
      celestia:print("Observer " .. key .. " is NOT valid.", 3.0, -1, -1, 2, 4)
   end
   wait(3.5)
end

返回到观察者 方法索引。

gettrackedobject

1.5.0 object observer:gettrackedobject()

返回当前在 CELX “object” 对象中跟踪的对象。

备注

1. 如果当前没有跟踪任何对象，则返回一个空对象。空对象与 nil 不同！
2. CELX “object” 对象可以引用一个天体，例如行星或恒星，但它也可以是一个位置或航天器。
3. 可以使用object 方法处理 CELX “object” 对象。“Object” 对象也可以用在其他方法中，这些方法需要一个“object” 对象作为参数。

示例
显示此观察者当前跟踪的对象名称。可以通过按键盘上的 [Esc] 键终止示例。
在运行此示例时，您可以选择不同的对象并按键盘上的 [T] 键来跟踪或停止跟踪该对象。

while true do
   obs = celestia:getobserver()
   tracked_obj = obs:gettrackedobject()
   tracked_obj_name = tracked_obj:name()
   if tracked_obj_name == "?" then
      celestia:print("No object currently tracked")
   else
      celestia:print("Tracking "..tracked_obj_name)
   end
   wait(0)
end

返回到观察者 方法索引。

makeactiveview

1.6.0 observer:makeactiveview()

使此观察者的视图成为当前活动视图。

示例
创建多视图后，确定哪个观察者是活动视图并为该观察者恢复单视图。

obs = celestia:getobserver()
obs:splitview("V", 0.5)
observers = celestia:getobservers()
venus = celestia:find("Sol/Venus")
observers[1]:gotodistance(venus, 50000)
mars = celestia:find("Sol/Mars")
observers[2]:gotodistance(mars, 30000)
wait(10.0)
observers[1]:makeactiveview()
obs = celestia:getobserver()
obs:singleview()

返回到观察者 方法索引。

orbit

1.6.1 observer:orbit(rotation:rot)

根据给定的旋转使观察者围绕当前参考对象旋转。

参数

rot

此观察者用于轨道的旋转。必须是一个“rotation”对象。

备注

1. 此方法会立即设置新的观察者位置和方向。为了更好地模拟 CEL: ORBIT 命令，并让观察者在一段时间内围绕某个轨道旋转，可以通过将旋转角度分成多个更小的旋转角度来实现。这些较小的旋转角度可以快速地依次处理。使用此 observer:orbit() 方法，通过 Lua “for” 或 “while” 控制结构（参见下一部分）。
2. 当在 Lua “for” 控制结构中使用此 observer:orbit() 方法时（参见示例 1），轨道周期将比 number:duration 秒多出一小部分（取决于计算机的速度），但绕指定轴旋转的总角度将是完全正确的。这是因为在生成的循环中，执行命令也会消耗一些额外的计算机时间。如果计算机速度较慢，可以减少每秒的步数，但这也可能意味着场景变得更加卡顿。
3. 也可以在 Lua “while” 控制结构中使用此 observer:orbit() 方法（参见示例 2）。在这种情况下，轨道周期可以精确地设置为 number:duration 秒，但绕指定轴旋转的总角度将不完全正确。同样，根据计算机的速度，您需要估计“while” 控制结构中每个序列的步长角度或等待时间，以便尽可能接近目标轨道角度。
4. 对于没有参考对象存在的通用参考系，即使选中了对象，使用此 observer:orbit() 方法也不会导致观察者绕某个轨道旋转！

示例 1
选择、跟踪并以地球为中心，然后使观察者在大约 10 秒内围绕地球的 Y 轴旋转精确地 360 度。

-- Find, select, follow and center Earth first.
earth = celestia:find("Sol/Earth")
celestia:select(earth)
obs = celestia:getobserver()
obs:follow(earth)
obs:center(earth, 1.0)
wait(1.0)
-- Orbit during about 10 seconds over 360 degrees, around the Y axis
duration = 10.0
orbitangle = math.rad(360.0)
axis_vector = celestia:newvector(0,1,0)
-- Split up the orbit in 30 steps per second and determine the orbit steptime for each single step.
-- The factor 0.75 is an estimate and may depend on the speed of your computer.
orbitsteps = 30 * duration
orbitsteptime = 0.75*duration/orbitsteps
-- Create new rotation object of split up orbit angle around the specified axis.
rot = celestia:newrotation(axis_vector, orbitangle/orbitsteps)
-- Actually execute the orbit.
for i = 1, orbitsteps do
   obs:orbit(rot)
   wait(orbitsteptime)
end

示例 2
选择、跟踪并以地球为中心，然后使观察者在精确地 10 秒内围绕地球的 Y 轴旋转大约 360 度。

-- Find, select, follow and center Earth first.
earth = celestia:find("Sol/Earth")
celestia:select(earth)
obs = celestia:getobserver()
obs:follow(earth)
obs:center(earth, 1.0)
wait(1.0)
-- Orbit during 10 seconds over about 360 degrees, around the Y axis
duration = 10.0
orbitangle = math.rad(360.0)
axis_vector = celestia:newvector(0, 1, 0)
-- Split up the orbit in 30 steps per second and determine the orbit steptime for each single step.
-- The factor 0.75 is an estimate and may depend on the speed of your computer.
orbitsteps = 30 * duration
orbitsteptime = 0.75*duration/orbitsteps
-- Create new rotation object of split up orbit angle around the specified axis.
rot = celestia:newrotation(axis_vector, orbitangle/orbitsteps)
-- Get the elapsed time in seconds since the script has been started and store in "t0". 
t0 = celestia:getscripttime()
-- Actually execute the orbit
while celestia:getscripttime() <= t0 + duration do
   obs:orbit(rot)
   wait(orbitsteptime)
end

返回到观察者 方法索引。