捕获教程
介绍
要使用 Zivid 相机捕获点云或 2D 图像:初始化 Zivid 应用程序、连接相机、配置捕获设置,然后捕获并保存结果。
有关相应的 API,请参阅 Camera Basic。
先决条件
安装 Zivid 软件 。
对于 Python:安装 zivid-python
初始化
调用 Zivid SDK 中的任何 API 都需要初始化 Zivid application 并在程序运行时使其保持活动状态。
备注
Application 必须在操作 Zivid 相机时保持活动状态。这本质上是 Zivid 的驱动程序。
连接
现在我们可以连接到相机了。
选定相机
当多台相机连接到同一台计算机时,如果需要在代码中使用某台特定的相机,可以通过该相机的序列号来实现。
备注
Zivid Studio 中显示的相机序列号。
也可以通过 IP 地址或主机名直接连接相机。这会绕过 mDNS 发现机制,因此连接不再局限于自动发现或序列号方式。
何时通过 IP 地址或主机名连接
在以下情况下直接连接会很有用:
相机位于与 PC 不同的子网,否则将无法访问。
mDNS 不可用,例如被网络策略、交换机或防火墙阻止时,或在 Docker容器中运行 时——其默认桥接网络不允许 mDNS 所依赖的多播流量通过。
您想以编程方式连接,而不依赖发现机制或用于列出相机的
Cameras.yml文件。
这通常适用于具有固定相机 IP 的生产单元、受管理网络上的多相机工作站,以及封闭或分段的工业网络。
相机的默认主机名遵循 zivid-<serial-number>.local 的格式。无法通过 SDK 获取或设置主机名。要进行设置,请使用 ZividNetworkCameraConfigurator CLI 工具,具体说明见 DHCP 网络配置。
您还可以使用 Application::cameras 列出所有连接到计算机的相机并查看它们的序列号:
auto cameras = zivid.cameras();
std::cout << "Found " << cameras.size() << " cameras" << std::endl;
for(auto &camera : cameras)
{
std::cout << camera.info() << std::endl;
std::cout << camera.state() << std::endl;
}
然后您可以连接到所有可用的相机。
std::vector<Zivid::Camera> connectedCameras;
for(auto &camera : zivid.cameras())
{
if(camera.state().status() == Zivid::CameraState::Status::available)
{
std::cout << "Connecting to camera: " << camera.info().serialNumber() << std::endl;
camera.connect();
connectedCameras.push_back(camera);
}
else
{
std::cout << "Camera " << camera.info().serialNumber() << " is not available. "
<< "Camera status: " << camera.state().status() << std::endl;
}
}
var connectedCameras = new List<Zivid.NET.Camera>();
foreach (var camera in zivid.Cameras)
{
if (camera.State.Status == Zivid.NET.CameraState.StatusOption.Available)
{
Console.WriteLine("Connecting to camera: " + camera.Info.SerialNumber);
camera.Connect();
connectedCameras.Add(camera);
}
else
{
Console.WriteLine("Camera " + camera.Info.SerialNumber + " is not available. "
+ "Camera status: " + camera.State.Status);
}
}
connected_cameras = []
for camera in app.cameras():
if camera.state.status == zivid.CameraState.Status.available:
print(f"Connecting to camera: {camera.info.serial_number}")
camera.connect()
connected_cameras.append(camera)
else:
print(f"Camera {camera.info.serial_number} is not available. Camera status: {camera.state.status}")
配置
与所有相机一样,都有可以配置的设置。
Presets(预设值)
建议使用 Zivid Studio 中提供的 Presets(预设值) 以及 .yml 文件(请参阅"加载"和"保存"部分)。预设值(Presets)适用于大多数情况,是一个很好的起点。如有需要,您可以微调设置以获得更好的效果。您可以使用任何文本编辑器编辑 YAML 文件,也可以手动编写设置代码。
加载
您可以从 Zivid Studio 将相机设置导出到 .yml 文件。这些文件可以在 API 中加载和应用。
const auto settingsFile = "Settings.yml";
std::cout << "Loading settings from file: " << settingsFile << std::endl;
const auto settingsFromFile = Zivid::Settings(settingsFile);
保存
您还可以将设置保存到.yml 文件。
手动配置
另一种选择是手动配置设置。有关每个设置的作用的更多信息,请参阅 相机设置。然后,下一步是 捕获高质量的点云
单次 2D 和 3D 采集 - 默认设置
我们可以为单个采集捕获创建设置。
const auto settings =
Zivid::Settings{ Zivid::Settings::Acquisitions{ Zivid::Settings::Acquisition{} },
Zivid::Settings::Color{ Zivid::Settings2D{
Zivid::Settings2D::Acquisitions{ Zivid::Settings2D::Acquisition{} } } } };
多次采集 HDR
我们还可以创建包含多次采集的设置,用于 HDR 捕获。
using std::chrono::microseconds;
Zivid::Settings settings;
for(const auto exposure : { microseconds{ 1000 }, microseconds{ 10000 } })
{
std::cout << "Adding acquisition with exposure time of " << exposure.count() << " microseconds "
<< std::endl;
const auto acquisitionSettings = Zivid::Settings::Acquisition{
Zivid::Settings::Acquisition::ExposureTime{ exposure },
};
settings.acquisitions().emplaceBack(acquisitionSettings);
}
var settings = new Zivid.NET.Settings();
foreach (var exposure in new Duration[] { Duration.FromMicroseconds(1000), Duration.FromMicroseconds(10000) })
{
Console.WriteLine("Adding acquisition with exposure time of " + exposure.Microseconds + " microseconds");
var acquisitionSettings = new Zivid.NET.Settings.Acquisition { ExposureTime = exposure };
settings.Acquisitions.Add(acquisitionSettings);
}
settings.Color = new Zivid.NET.Settings2D { Acquisitions = { new Zivid.NET.Settings2D.Acquisition { } } };
settings = zivid.Settings()
for exposure in [1000, 10000]:
print(f"Adding acquisition with exposure time of {exposure} microseconds")
settings.acquisitions.append(
zivid.Settings.Acquisition(exposure_time=datetime.timedelta(microseconds=exposure))
)
完整配置的设置
2D 设置,例如色彩平衡和伽玛值,需手动配置:
std::cout << "Configuring settings for capture:" << std::endl;
Zivid::Settings2D settings2D{
Zivid::Settings2D::Sampling::Color::rgb,
Zivid::Settings2D::Sampling::Pixel::all,
Zivid::Settings2D::Sampling::Interval::Enabled::no,
Zivid::Settings2D::Sampling::Interval::Duration{ microseconds{ 10000 } },
Zivid::Settings2D::Processing::Color::Balance::Blue{ 1.0 },
Zivid::Settings2D::Processing::Color::Balance::Green{ 1.0 },
Zivid::Settings2D::Processing::Color::Balance::Red{ 1.0 },
Zivid::Settings2D::Processing::Color::Gamma{ 1.0 },
Zivid::Settings2D::Processing::Color::Experimental::Mode::automatic,
};
Console.WriteLine("Configuring settings for capture:");
var settings2D = new Zivid.NET.Settings2D()
{
Sampling =
{
Color = Zivid.NET.Settings2D.SamplingGroup.ColorOption.Rgb,
Pixel = Zivid.NET.Settings2D.SamplingGroup.PixelOption.All,
Interval =
{
Enabled = false,
Duration = Duration.FromMicroseconds(10000),
},
},
Processing =
{
Color =
{
Balance =
{
Blue = 1.0,
Green = 1.0,
Red = 1.0,
},
Gamma = 1.0,
Experimental = { Mode = Zivid.NET.Settings2D.ProcessingGroup.ColorGroup.ExperimentalGroup.ModeOption.Automatic },
},
},
};
print("Configuring settings for capture:")
settings_2d = zivid.Settings2D()
settings_2d.sampling.color = zivid.Settings2D.Sampling.Color.rgb
settings_2d.sampling.pixel = zivid.Settings2D.Sampling.Pixel.all
settings_2d.sampling.interval.enabled = False
settings_2d.sampling.interval.duration = timedelta(microseconds=10000)
settings_2d.processing.color.balance.red = 1.0
settings_2d.processing.color.balance.blue = 1.0
settings_2d.processing.color.balance.green = 1.0
settings_2d.processing.color.gamma = 1.0
settings_2d.processing.color.experimental.mode = zivid.Settings2D.Processing.Color.Experimental.Mode.automatic
手动配置的 3D 设置,例如 engine、感兴趣区域、过滤器设置等:
Zivid::Settings settings{
Zivid::Settings::Color{ settings2D },
Zivid::Settings::Engine::stripe,
Zivid::Settings::RegionOfInterest::Box::Enabled::yes,
Zivid::Settings::RegionOfInterest::Box::PointO{ 1000, 1000, 1000 },
Zivid::Settings::RegionOfInterest::Box::PointA{ 1000, -1000, 1000 },
Zivid::Settings::RegionOfInterest::Box::PointB{ -1000, 1000, 1000 },
Zivid::Settings::RegionOfInterest::Box::Extents{ -1000, 1000 },
Zivid::Settings::RegionOfInterest::Depth::Enabled::yes,
Zivid::Settings::RegionOfInterest::Depth::Range{ 200, 2000 },
Zivid::Settings::Processing::Filters::Cluster::Removal::Enabled::yes,
Zivid::Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance{ 10 },
Zivid::Settings::Processing::Filters::Cluster::Removal::MinArea{ 100 },
Zivid::Settings::Processing::Filters::Hole::Repair::Enabled::yes,
Zivid::Settings::Processing::Filters::Hole::Repair::HoleSize{ 0.2 },
Zivid::Settings::Processing::Filters::Hole::Repair::Strictness{ 1 },
Zivid::Settings::Processing::Filters::Noise::Removal::Enabled::yes,
Zivid::Settings::Processing::Filters::Noise::Removal::Threshold{ 7.0 },
Zivid::Settings::Processing::Filters::Noise::Suppression::Enabled::yes,
Zivid::Settings::Processing::Filters::Noise::Repair::Enabled::yes,
Zivid::Settings::Processing::Filters::Outlier::Removal::Enabled::yes,
Zivid::Settings::Processing::Filters::Outlier::Removal::Threshold{ 5.0 },
Zivid::Settings::Processing::Filters::Reflection::Removal::Enabled::yes,
Zivid::Settings::Processing::Filters::Reflection::Removal::Mode::global,
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Enabled::yes,
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Sigma{ 1.5 },
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled::yes,
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength{ 0.4 },
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled::no,
Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold{ 0.5 },
Zivid::Settings::Processing::Resampling::Mode::upsample2x2,
Zivid::Settings::Diagnostics::Enabled::no,
};
setSamplingPixel(settings, camera);
std::cout << settings << std::endl;
var settings = new Zivid.NET.Settings()
{
Engine = Zivid.NET.Settings.EngineOption.Stripe,
RegionOfInterest =
{
Box = {
Enabled = true,
PointO = new Zivid.NET.PointXYZ{ x = 1000, y = 1000, z = 1000 },
PointA = new Zivid.NET.PointXYZ{ x = 1000, y = -1000, z = 1000 },
PointB = new Zivid.NET.PointXYZ{ x = -1000, y = 1000, z = 1000 },
Extents = new Zivid.NET.Range<double>(-1000, 1000),
},
Depth =
{
Enabled = true,
Range = new Zivid.NET.Range<double>(200, 2000),
},
},
Processing =
{
Filters =
{
Cluster =
{
Removal = { Enabled = true, MaxNeighborDistance = 10, MinArea = 100}
},
Hole =
{
Repair = { Enabled = true, HoleSize = 0.2, Strictness = 1 },
},
Noise =
{
Removal = { Enabled = true, Threshold = 7.0 },
Suppression = { Enabled = true },
Repair = { Enabled = true },
},
Outlier =
{
Removal = { Enabled = true, Threshold = 5.0 },
},
Reflection =
{
Removal = { Enabled = true, Mode = ReflectionFilterModeOption.Global },
},
Smoothing =
{
Gaussian = { Enabled = true, Sigma = 1.5 },
},
Experimental =
{
ContrastDistortion =
{
Correction = { Enabled = true, Strength = 0.4 },
Removal = { Enabled = true, Threshold = 0.5 },
},
},
},
Resampling = { Mode = Zivid.NET.Settings.ProcessingGroup.ResamplingGroup.ModeOption.Upsample2x2 },
},
Diagnostics = { Enabled = false },
};
settings.Color = settings2D;
SetSamplingPixel(ref settings, camera);
Console.WriteLine(settings);
settings = zivid.Settings()
settings.engine = zivid.Settings.Engine.stripe
settings.region_of_interest.box.enabled = True
settings.region_of_interest.box.point_o = [1000, 1000, 1000]
settings.region_of_interest.box.point_a = [1000, -1000, 1000]
settings.region_of_interest.box.point_b = [-1000, 1000, 1000]
settings.region_of_interest.box.extents = [-1000, 1000]
settings.region_of_interest.depth.enabled = True
settings.region_of_interest.depth.range = [200, 2000]
settings.processing.filters.cluster.removal.enabled = True
settings.processing.filters.cluster.removal.max_neighbor_distance = 10
settings.processing.filters.cluster.removal.min_area = 100
settings.processing.filters.hole.repair.enabled = True
settings.processing.filters.hole.repair.hole_size = 0.2
settings.processing.filters.hole.repair.strictness = 1
settings.processing.filters.noise.removal.enabled = True
settings.processing.filters.noise.removal.threshold = 7.0
settings.processing.filters.noise.suppression.enabled = True
settings.processing.filters.noise.repair.enabled = True
settings.processing.filters.outlier.removal.enabled = True
settings.processing.filters.outlier.removal.threshold = 5.0
settings.processing.filters.reflection.removal.enabled = True
settings.processing.filters.reflection.removal.mode = (
zivid.Settings.Processing.Filters.Reflection.Removal.Mode.global_
)
settings.processing.filters.smoothing.gaussian.enabled = True
settings.processing.filters.smoothing.gaussian.sigma = 1.5
settings.processing.filters.experimental.contrast_distortion.correction.enabled = True
settings.processing.filters.experimental.contrast_distortion.correction.strength = 0.4
settings.processing.filters.experimental.contrast_distortion.removal.enabled = False
settings.processing.filters.experimental.contrast_distortion.removal.threshold = 0.5
settings.processing.resampling.mode = zivid.Settings.Processing.Resampling.Mode.upsample2x2
settings.diagnostics.enabled = False
settings.color = settings_2d
_set_sampling_pixel(settings, camera)
print(settings)
也可以为每次采集设置不同的值:
std::cout << "Configuring acquisition settings different for all HDR acquisitions" << std::endl;
const auto baseAcquisition = Zivid::Settings::Acquisition{};
std::cout << baseAcquisition << std::endl;
auto exposureValues = getExposureValues(camera);
const std::vector<double> aperture = std::get<0>(exposureValues);
const std::vector<double> gain = std::get<1>(exposureValues);
const std::vector<std::chrono::microseconds> exposureTime = std::get<2>(exposureValues);
const std::vector<double> brightness = std::get<3>(exposureValues);
for(size_t i = 0; i < aperture.size(); ++i)
{
std::cout << "Acquisition " << i + 1 << ":" << std::endl;
std::cout << " Exposure Time: " << exposureTime.at(i).count() << std::endl;
std::cout << " Aperture: " << aperture.at(i) << std::endl;
std::cout << " Gain: " << gain.at(i) << std::endl;
std::cout << " Brightness: " << brightness.at(i) << std::endl;
const auto acquisitionSettings = baseAcquisition.copyWith(
Zivid::Settings::Acquisition::Aperture{ aperture.at(i) },
Zivid::Settings::Acquisition::Gain{ gain.at(i) },
Zivid::Settings::Acquisition::ExposureTime{ exposureTime.at(i) },
Zivid::Settings::Acquisition::Brightness{ brightness.at(i) });
settings.acquisitions().emplaceBack(acquisitionSettings);
}
const auto aquisitionSettings2D = makeSettings2D(camera).acquisitions();
settings.color().value().set(aquisitionSettings2D);
Console.WriteLine("Configuring acquisition settings different for all HDR acquisitions:");
var baseAcquisition = new Zivid.NET.Settings.Acquisition { };
Console.WriteLine(baseAcquisition);
var baseAcquisition2D = new Zivid.NET.Settings2D.Acquisition { };
Tuple<double[], Duration[], double[], double[]> exposureValues = GetExposureValues(camera);
double[] aperture = exposureValues.Item1;
Duration[] exposureTime = exposureValues.Item2;
double[] gain = exposureValues.Item3;
double[] brightness = exposureValues.Item4;
for (int i = 0; i < aperture.Length; i++)
{
Console.WriteLine("Acquisition {0}:", i + 1);
Console.WriteLine(" Exposure Time: {0}", exposureTime[i].Microseconds);
Console.WriteLine(" Aperture: {0}", aperture[i]);
Console.WriteLine(" Gain: {0}", gain[i]);
Console.WriteLine(" Brightness: {0}", brightness[i]);
var acquisitionSettings = baseAcquisition.CopyWith(s =>
{
s.Aperture = aperture[i];
s.ExposureTime = exposureTime[i];
s.Gain = gain[i];
s.Brightness = brightness[i];
});
settings.Acquisitions.Add(acquisitionSettings);
}
var aquisitionSettings2D = MakeSettings2D(camera);
settings.Color.Acquisitions = aquisitionSettings2D.Acquisitions;
print("Configuring acquisition settings different for all HDR acquisitions")
exposure_values = _get_exposure_values(camera)
for aperture, gain, exposure_time, brightness in exposure_values:
settings.acquisitions.append(
zivid.Settings.Acquisition(
aperture=aperture,
exposure_time=exposure_time,
brightness=brightness,
gain=gain,
)
)
acquisition_settings_2d = make_settings_2d(camera).Acquisition()
settings.color.acquisitions.append(acquisition_settings_2d)
捕获 2D3D
现在我们可以采集 2D 和 3D 图像(带颜色的点云)了。单次采集还是多次采集(HDR)由 settings 中的 acquisitions 数量决定。
Frame 包含了点云、彩色图像、捕获和相机信息(所有这些都存储在计算设备内存中)。
Frame 包含了点云、彩色图像、捕获和相机信息(所有这些都存储在计算设备内存中)。
zivid.Frame 包含了点云、彩色图像、捕获和相机信息(所有这些都存储在计算设备内存中)。
捕获 3D
If we only want to capture 3D, the points cloud without color, we can do so via Camera::capture3D().
捕获 2D 图像
If we only want to capture a 2D image, which is faster than 3D, we can do so via Camera::capture2D().
保存
我们现在可以保存结果了。
小技巧
您可以在 Zivid Studio 中打开并查看 Frame.zdf 文件。
导出
在下一个代码示例中,点云将导出为 .ply 格式。有关其他导出选项,请参阅 点云 以获取支持的格式列表。
加载
保存后,可以从 ZDF 文件加载图像帧。
const auto dataFile = std::string(ZIVID_SAMPLE_DATA_DIR) + "/Zivid3D.zdf";
std::cout << "Reading ZDF frame from file: " << dataFile << std::endl;
const auto frame = Zivid::Frame(dataFile);
保存 2D 图像
From a Camera::capture2D() you get a Frame2D.
There are two color spaces available for 2D images: linear RGB and sRGB.
The Frame2D::imageRGBA() will return an image in the linear RGB color space.
If you append _SRGB to the function name then the returned image will be in the sRGB color space.
First, get the 2D image from the capture in either color space.
Get image (Linear RGB)
获取 linear RGB 颜色空间的 2D 图像:
Get image (sRGB)
获取 sRGB 颜色空间的 2D 图像:
然后,我们可以将 2D 图像保存在线性 RGB 或 sRGB 颜色空间中。
Save image (Linear RGB)
保存 linear RGB 颜色空间的 2D 图像:
const auto imageFile = "ImageRGBA_linear.png";
std::cout << "Saving 2D color image (Linear RGB) to file: " << imageFile << std::endl;
imageRGBA.save(imageFile);
Save image (sRGB)
保存 sRGB 颜色空间的 2D 图像:
const auto imageFile = "ImageRGBA_sRGB.png";
std::cout << "Saving 2D color image (sRGB color space) to file: " << imageFile << std::endl;
imageSRGB.save(imageFile);
我们可以直接从点云获取 2D 彩色图像。该图像将具有与点云相同的分辨率,并且位于 sRGB 颜色空间中。
const auto pointCloud = frame.pointCloud();
const auto image2DInPointCloudResolution = pointCloud.copyImageRGBA_SRGB();
var pointCloud = frame.PointCloud;
var image2DInPointCloudResolution = pointCloud.CopyImageRGBA_SRGB();
point_cloud = frame.point_cloud()
image_2d_in_point_cloud_resolution = point_cloud.copy_image("bgra_srgb")
We can get the 2D color image from Frame2D, which is part of the Frame object, obtained from Camera::capture2D3D().
This image will have the resolution given by the 2D settings inside the 2D3D settings.
const auto image2D = frame.frame2D().value().imageBGRA_SRGB();
var image2D = frame.Frame2D.ImageBGRA_SRGB();
image_2d = frame.frame_2d().image_bgra_srgb()
文件相机
借助 文件相机,您可以在没有物理相机的情况下体验 SDK。文件相机可以在 Sample Data(示例数据) 中找到,其中有多个文件相机可供选择。
采集设置必须按照后续示例中所示进行初始化,但您可以自由更改处理设置。
std::cout << "Configuring settings" << std::endl;
Zivid::Settings settings{
Zivid::Settings::Acquisitions{ Zivid::Settings::Acquisition{} },
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Enabled::yes,
Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Sigma{ 1.5 },
Zivid::Settings::Processing::Filters::Reflection::Removal::Enabled::yes,
Zivid::Settings::Processing::Filters::Reflection::Removal::Mode::global,
};
settings.set(
Zivid::Settings::RegionOfInterest::Box{
Zivid::Settings::RegionOfInterest::Box::Enabled::yes,
Zivid::Settings::RegionOfInterest::Box::PointO{ { -266, 190, 771 } },
Zivid::Settings::RegionOfInterest::Box::PointA{ { 203, 207, 771 } },
Zivid::Settings::RegionOfInterest::Box::PointB{ { -255, -131, 771 } },
Zivid::Settings::RegionOfInterest::Box::Extents{ 0, 298 } });
Zivid::Settings2D settings2D{ Zivid::Settings2D::Acquisitions{ Zivid::Settings2D::Acquisition{} } };
settings.color() = Zivid::Settings::Color{ settings2D };
Console.WriteLine("Configuring settings");
var settings2D = new Zivid.NET.Settings2D
{
Acquisitions = { new Zivid.NET.Settings2D.Acquisition { } }
};
var settings = new Zivid.NET.Settings
{
Acquisitions = { new Zivid.NET.Settings.Acquisition { } },
Processing =
{
Filters =
{
Smoothing =
{
Gaussian = { Enabled = true, Sigma = 1.5 }
},
Reflection =
{
Removal = { Enabled = true, Mode = ReflectionFilterModeOption.Global}
}
}
}
};
var roiBox = new Zivid.NET.Settings.RegionOfInterestGroup.BoxGroup
{
Enabled = true,
PointO = new Zivid.NET.PointXYZ { x = -266, y = 190, z = 771 },
PointA = new Zivid.NET.PointXYZ { x = 203, y = 207, z = 771 },
PointB = new Zivid.NET.PointXYZ { x = -255, y = -131, z = 771 }
};
roiBox.Extents = new Zivid.NET.Range<double>(0, 298);
settings.RegionOfInterest.Box = roiBox;
settings.Color = settings2D;
print("Configuring settings")
settings = zivid.Settings()
settings.acquisitions.append(zivid.Settings.Acquisition())
settings.processing.filters.smoothing.gaussian.enabled = True
settings.processing.filters.smoothing.gaussian.sigma = 1.5
settings.processing.filters.reflection.removal.enabled = True
settings.processing.filters.reflection.removal.mode = (
zivid.Settings.Processing.Filters.Reflection.Removal.Mode.global_
)
settings.region_of_interest.box = zivid.Settings.RegionOfInterest.Box(
enabled=True,
point_o=(-266, 190, 771),
point_a=(203, 207, 771),
point_b=(-255, -131, 771),
extents=(0, 298),
)
settings_2d = zivid.Settings2D()
settings_2d.acquisitions.append(zivid.Settings2D.Acquisition())
settings.color = settings_2d
您可以在 File Camera(文件相机) 中阅读有关文件相机选项的更多信息。
多线程
相机对象上的操作是线程安全的,但列出相机和连接相机等其他操作必须按顺序执行。您可以在 多线程 中了解更多信息。
结论
本教程展示了如何使用 Zivid SDK 进行相机的连接、配置、捕获和保存文件。
Version History
SDK |
变更 |
|---|---|
2.18.0 |
新增通过 IP 地址或主机名连接相机的功能。 |