Capture Tutorial

Introduction

이 튜토리얼에서는 Zivid SDK를 사용하여 포인트 클라우드 및 2D 이미지를 캡처하는 방법을 설명합니다.

MATLAB의 경우 Zivid Capture Tutorial for MATLAB 을 확인하세요.

팁

비디오 시청을 선호하는 경우 웹 세미나 Making 3D captures easy - A tour of Zivid Studio and Zivid SDK 에서 캡처 튜토리얼과 동일한 내용을 다룹니다.

Prerequisites

• 설치 Zivid Software.

• Python의 경우: zivid-python 을 설치합니다.

Initialize

Zivid SDK에서 API를 호출하려면 Zivid 애플리케이션을 초기화하고 프로그램이 실행되는 동안 활성 상태를 유지해야 합니다.

참고

Zivid::Application Zivid 카메라를 작동하는 동안 살아 있어야 합니다. 이것은 본질적으로 Zivid 드라이버입니다.

C++

source

Zivid::Application zivid;

C#

소스

var zivid = new Zivid.NET.Application();

Python

source

app = zivid.Application()

Connect

이제 카메라에 연결할 수 있습니다.

C++

source

auto camera = zivid.connectCamera();

C#

소스

var camera = zivid.ConnectCamera();

Python

source

camera = app.connect_camera()

Specific Camera

때로는 여러 대의 카메라가 동일한 컴퓨터에 연결되어 있지만 코드에서 특정 카메라로 작업해야 할 수도 있습니다. 원하는 카메라의 일련 번호를 제공하면 됩니다.

C++

auto camera = zivid.connectCamera(Zivid::CameraInfo::SerialNumber{ "2020C0DE" });

C#

var camera = zivid.ConnectCamera(new Zivid.NET.CameraInfo.SerialNumber("2020C0DE"));

Python

camera = app.connect_camera(serial_number="2020C0DE")

참고

카메라의 일련 번호는 Zivid Studio에 표시됩니다.

컴퓨터에 연결된 모든 카메라를 나열하고 일련 번호도 확인할 수 있습니다.

C++

source

auto cameras = zivid.cameras();
std::cout << "Found " << cameras.size() << " cameras" << std::endl;
for(auto &camera : cameras)
{
    std::cout << "Camera Info: " << camera.info() << std::endl;
    std::cout << "Camera State: " << camera.state() << std::endl;
}

C#

source

var cameras = zivid.Cameras;
Console.WriteLine("Number of cameras found: {0}", cameras.Count);
foreach (var camera in cameras)
{
    Console.WriteLine("Camera Info: {0}", camera.Info);
    Console.WriteLine("Camera State: {0}", camera.State);
}

Python

source

cameras = app.cameras()
for camera in cameras:
    print(f"Camera Info:  {camera.info}")
    print(f"Camera State: {camera.state}")

File Camera

파일 카메라 옵션을 사용하면 실제 카메라에 액세스하지 않고도 SDK를 테스트할 수 있습니다. 파일 카메라는 각각의 카메라 모델에 해당하는 파일 카메라를 Sample Data 에서 찾을 수 있습니다. 각 파일 카메라는 각 카메라 모델의 주요 애플리케이션 중 하나 내에서 사용 사례를 보여줍니다. 아래 예제는 Sample Data 에서 Zivid 2 M70 파일 카메라를 사용하여 파일 카메라를 생성하는 방법을 보여줍니다.

C++

소스

const auto fileCamera =
    userInput ? fileCameraPath : std::string(ZIVID_SAMPLE_DATA_DIR) + "/FileCameraZivid2M70.zfc";

C#

소스

fileCamera = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData) + "/Zivid/FileCameraZivid2M70.zfc";

Python

소스

default=get_sample_data_path() / "FileCameraZivid2M70.zfc",

C++

소스

auto camera = zivid.createFileCamera(fileCamera);

C#

소스

var camera = zivid.CreateFileCamera(fileCamera);

Python

소스

camera = app.create_file_camera(file_camera)

획득 설정은 아래와 같이 초기화되어야 하지만 처리 설정을 자유롭게 변경할 수 있습니다.

C++

source

const auto settings = Zivid::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,
                                       Zivid::Settings::Processing::Color::Balance::Red{ 1 },
                                       Zivid::Settings::Processing::Color::Balance::Green{ 1 },
                                       Zivid::Settings::Processing::Color::Balance::Blue{ 1 } };

C#

소스

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} } },
                   Color = { Balance = { Red = 1.0, Green = 1.0, Blue = 1.0 } } }
};

Python

소스

settings = zivid.Settings()
settings.acquisitions.append(zivid.Settings.Acquisition())
settings.processing.filters.smoothing.gaussian.enabled = True
settings.processing.filters.smoothing.gaussian.sigma = 1
settings.processing.filters.reflection.removal.enabled = True
settings.processing.filters.reflection.removal.mode = "global"
settings.processing.color.balance.red = 1.0
settings.processing.color.balance.green = 1.0
settings.processing.color.balance.blue = 1.0

파일 카메라 옵션에 대한 자세한 내용은 File Camera 에서 확인할 수 있습니다.

Configure

모든 카메라와 마찬가지로 구성할 수 있는 설정이 있습니다.

Presets

Zivid Studio에서 제공하고 .yml 파일로 저장할 수 있는 Presets 사용을 추천드립니다(Load 참조). 또는 Capture Assistant를 사용하거나 설정을 수동으로 구성할 수 있습니다.

Capture Assistant

구성할 설정을 알기 어려울 수 있습니다. Zivid에는 Capture Assistant가 있습니다. 이것은 카메라 설정을 구성하는 데 도움이 되고 Zivid SDK에서 사용할 수 있습니다.

C++

소스

const auto suggestSettingsParameters = Zivid::CaptureAssistant::SuggestSettingsParameters{
    Zivid::CaptureAssistant::SuggestSettingsParameters::AmbientLightFrequency::none,
    Zivid::CaptureAssistant::SuggestSettingsParameters::MaxCaptureTime{ std::chrono::milliseconds{ 1200 } }
};

std::cout << "Running Capture Assistant with parameters:\n" << suggestSettingsParameters << std::endl;
auto settings = Zivid::CaptureAssistant::suggestSettings(camera, suggestSettingsParameters);

C#

소스

var suggestSettingsParameters = new Zivid.NET.CaptureAssistant.SuggestSettingsParameters
{
    AmbientLightFrequency =
        Zivid.NET.CaptureAssistant.SuggestSettingsParameters.AmbientLightFrequencyOption.none,
    MaxCaptureTime = Duration.FromMilliseconds(1200)
};

Console.WriteLine("Running Capture Assistant with parameters:\n{0}", suggestSettingsParameters);
var settings = Zivid.NET.CaptureAssistant.Assistant.SuggestSettings(camera, suggestSettingsParameters);

Python

소스

suggest_settings_parameters = zivid.capture_assistant.SuggestSettingsParameters(
    max_capture_time=datetime.timedelta(milliseconds=1200),
    ambient_light_frequency=zivid.capture_assistant.SuggestSettingsParameters.AmbientLightFrequency.none,
)

print(f"Running Capture Assistant with parameters: {suggest_settings_parameters}")
settings = zivid.capture_assistant.suggest_settings(camera, suggest_settings_parameters)

Capture Assistant로 구성할 parameter는 두 가지뿐입니다.

1. Maximum Capture Time (ms).

   1. 최소 캡처 시간은 200ms입니다. 이때 하나의 획득(acquisition)만 허용합니다.

   2. 이 알고리즘은 주어진 시간이 허용하는 경우 여러 획득(acquisition)을 결합합니다.

   3. 알고리즘은 가능한 한 장면의 동적 범위(Dynamic range)를 많이 포함하려고 시도합니다.

   4. 1초 이상의 최대 캡처 시간은 대부분의 시나리오에서 양호한 적용 범위를 갖습니다.

2. Ambient light compensation

   1. 주변 조명 주파수의 배수인 노출 기간으로 Capture Assistant를 제한할 수 있습니다.

   2. 60Hz는 일본, 미주, 대만, 한국 및 필리핀에서 사용됩니다.

   3. 50Hz는 나머지 세계에서 일반적입니다.

Manual configuration

Another option is to configure settings manually. For more information about what each settings does, please see Camera Settings. Then, the next step it’s Capturing High Quality Point Clouds

Single Acquisition

단일 획득 캡처에 대한 설정을 만들 수 있습니다.

C++

source

const auto settings = Zivid::Settings(Zivid::Settings::Acquisitions{ Zivid::Settings::Acquisition{} });

C#

source

var settings = new Zivid.NET.Settings
{
    Acquisitions = { new Zivid.NET.Settings.Acquisition { } }
};

Python

source

settings = zivid.Settings()
settings.acquisitions.append(zivid.Settings.Acquisition())

Multi Acquisition HDR

multi-acquisition HDR 캡처에 사용할 설정을 만들 수도 있습니다.

C++

소스

Zivid::Settings settings;
for(const auto aperture : { 11.31, 5.66, 2.83 })
{
    std::cout << "Adding acquisition with aperture = " << aperture << std::endl;
    const auto acquisitionSettings = Zivid::Settings::Acquisition{
        Zivid::Settings::Acquisition::Aperture{ aperture },
    };
    settings.acquisitions().emplaceBack(acquisitionSettings);
}

C#

소스

var settings = new Zivid.NET.Settings();
foreach (var aperture in new double[] { 9.57, 4.76, 2.59 })
{
    Console.WriteLine("Adding acquisition with aperture = " + aperture);
    var acquisitionSettings = new Zivid.NET.Settings.Acquisition { Aperture = aperture };
    settings.Acquisitions.Add(acquisitionSettings);
}

Python

소스

settings = zivid.Settings(acquisitions=[zivid.Settings.Acquisition(aperture=fnum) for fnum in (11.31, 5.66, 2.83)])

완전히 구성된 설정은 아래에 설명되어 있습니다.

C++

source

std::cout << "Configuring settings for capture:" << std::endl;
Zivid::Settings settings{
    Zivid::Settings::Engine::phase,
    Zivid::Settings::Sampling::Color::rgb,
    Zivid::Settings::Sampling::Pixel::blueSubsample2x2,
    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::Smoothing::Gaussian::Enabled::yes,
    Zivid::Settings::Processing::Filters::Smoothing::Gaussian::Sigma{ 1.5 },
    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::Cluster::Removal::Enabled::yes,
    Zivid::Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance{ 10 },
    Zivid::Settings::Processing::Filters::Cluster::Removal::MinArea{ 100 },
    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::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::Resampling::Mode::upsample2x2,
    Zivid::Settings::Processing::Color::Balance::Red{ 1.0 },
    Zivid::Settings::Processing::Color::Balance::Green{ 1.0 },
    Zivid::Settings::Processing::Color::Balance::Blue{ 1.0 },
    Zivid::Settings::Processing::Color::Gamma{ 1.0 },
    Zivid::Settings::Processing::Color::Experimental::Mode::automatic
};
std::cout << settings << std::endl;

std::cout << "Configuring base acquisition with settings same for all HDR acquisition:" << std::endl;
const auto baseAcquisition = Zivid::Settings::Acquisition{};
std::cout << baseAcquisition << std::endl;

std::cout << "Configuring acquisition settings different for all HDR acquisitions" << 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);
}

C#

source

Console.WriteLine("Configuring settings for capture:");
var settings = new Zivid.NET.Settings()
{
    Engine = Zivid.NET.Settings.EngineOption.Phase,
    Sampling = { Color = Zivid.NET.Settings.SamplingGroup.ColorOption.Rgb, Pixel = Zivid.NET.Settings.SamplingGroup.PixelOption.BlueSubsample2x2 },
    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 = { Smoothing = { Gaussian = { Enabled = true, Sigma = 1.5 } },
                               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} },
                               Cluster = { Removal = { Enabled = true, MaxNeighborDistance = 10, MinArea = 100} },
                               Hole = { Repair = { Enabled = true, HoleSize = 0.2, Strictness = 1 } },
                               Experimental = { ContrastDistortion = { Correction = { Enabled = true,
                                                                                      Strength = 0.4 },
                                                                       Removal = { Enabled = true,
                                                                                   Threshold = 0.5 } } } },
                   Resampling = { Mode = Zivid.NET.Settings.ProcessingGroup.ResamplingGroup.ModeOption.Upsample2x2},
                   Color = { Balance = { Red = 1.0, Green = 1.0, Blue = 1.0 },
                             Gamma = 1.0,
                             Experimental = { Mode = ColorModeOption.Automatic } } }
};
Console.WriteLine(settings);

Console.WriteLine("Configuring base acquisition with settings same for all HDR acquisitions:");
var baseAcquisition = new Zivid.NET.Settings.Acquisition { };
Console.WriteLine(baseAcquisition);

Console.WriteLine("Configuring acquisition settings different for all HDR acquisitions:");
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);
}

Python

source

print("Configuring settings for capture:")
settings = zivid.Settings()
settings.engine = zivid.Settings.Engine.phase
settings.sampling.color = zivid.Settings.Sampling.Color.rgb
settings.sampling.pixel = zivid.Settings.Sampling.Pixel.blueSubsample2x2
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]
filters = settings.processing.filters
filters.smoothing.gaussian.enabled = True
filters.smoothing.gaussian.sigma = 1.5
filters.noise.removal.enabled = True
filters.noise.removal.threshold = 7.0
filters.noise.suppression.enabled = True
filters.noise.repair.enabled = True
filters.outlier.removal.enabled = True
filters.outlier.removal.threshold = 5.0
filters.reflection.removal.enabled = True
filters.reflection.removal.mode = zivid.Settings.Processing.Filters.Reflection.Removal.Mode.global_
filters.cluster.removal.enabled = True
filters.cluster.removal.max_neighbor_distance = 10
filters.cluster.removal.min_area = 100
filters.experimental.contrast_distortion.correction.enabled = True
filters.experimental.contrast_distortion.correction.strength = 0.4
filters.experimental.contrast_distortion.removal.enabled = False
filters.experimental.contrast_distortion.removal.threshold = 0.5
filters.hole.repair.enabled = True
filters.hole.repair.hole_size = 0.2
filters.hole.repair.strictness = 1
resampling = settings.processing.resampling
resampling.mode = zivid.Settings.Processing.Resampling.Mode.upsample2x2
color = settings.processing.color
color.balance.red = 1.0
color.balance.blue = 1.0
color.balance.green = 1.0
color.gamma = 1.0
settings.processing.color.experimental.mode = zivid.Settings.Processing.Color.Experimental.Mode.automatic
print(settings)

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,
        )
    )

2D Settings

2D 이미지만 캡처할 수 있습니다. 이것은 3D 캡처보다 빠릅니다. 2D 설정은 다음과 같이 구성됩니다.

C++

소스

const auto settings2D =
    Zivid::Settings2D{ Zivid::Settings2D::Acquisitions{ Zivid::Settings2D::Acquisition{
                           Zivid::Settings2D::Acquisition::ExposureTime{ std::chrono::microseconds{ 30000 } },
                           Zivid::Settings2D::Acquisition::Aperture{ 11.31 },
                           Zivid::Settings2D::Acquisition::Brightness{ 1.80 },
                           Zivid::Settings2D::Acquisition::Gain{ 2.0 } } },
                       Zivid::Settings2D::Processing::Color::Balance::Red{ 1 },
                       Zivid::Settings2D::Processing::Color::Balance::Green{ 1 },
                       Zivid::Settings2D::Processing::Color::Balance::Blue{ 1 } };

C#

소스

var settings2D = new Zivid.NET.Settings2D
{
    Acquisitions = { new Zivid.NET.Settings2D.Acquisition {
        Aperture = 11.31, ExposureTime = Duration.FromMicroseconds(30000), Gain = 2.0, Brightness = 1.80
    } },
    Processing = { Color = { Balance = { Red = 1.0, Blue = 1.0, Green = 1.0 } } }
};

Python

소스

settings_2d = zivid.Settings2D()
settings_2d.acquisitions.append(zivid.Settings2D.Acquisition())
settings_2d.acquisitions[0].exposure_time = datetime.timedelta(microseconds=30000)
settings_2d.acquisitions[0].aperture = 11.31
settings_2d.acquisitions[0].brightness = 1.80
settings_2d.acquisitions[0].gain = 2.0
settings_2d.processing.color.balance.red = 1.0
settings_2d.processing.color.balance.green = 1.0
settings_2d.processing.color.balance.blue = 1.0
settings_2d.processing.color.gamma = 1.0

Load

Zivid Studio는 현재 설정을 .yml 파일에 저장할 수 있고 API에서 읽고 적용할 수 있습니다. 선호하는 편집기에서 이러한 (사람이 읽을 수 있는) yaml 파일의 설정을 수정하는 것이 더 쉬울 수 있습니다. 애플리케이션에 맞게 조정된 추천 .yml 파일은 Presets 을 확인하십시오.

C++

source

const auto settingsFile = "Settings.yml";
std::cout << "Loading settings from file: " << settingsFile << std::endl;
const auto settingsFromFile = Zivid::Settings(settingsFile);

C#

source

var settingsFile = "Settings.yml";
Console.WriteLine("Loading settings from file: " + settingsFile);
var settingsFromFile = new Zivid.NET.Settings(settingsFile);

Python

source

settings_file = "Settings.yml"
print(f"Loading settings from file: {settings_file}")
settings_from_file = zivid.Settings.load(settings_file)

Save

설정을 .yml 파일의 형태로 저장할 수 있습니다.

C++

source

const auto settingsFile = "Settings.yml";
std::cout << "Saving settings to file: " << settingsFile << std::endl;
settings.save(settingsFile);

C#

source

var settingsFile = "Settings.yml";
Console.WriteLine("Saving settings to file: " + settingsFile);
settings.Save(settingsFile);

Python

source

settings_file = "Settings.yml"
print(f"Saving settings to file: {settings_file}")
settings.save(settings_file)

조심

Zivid 설정 파일은 .yaml이 아닌 .yml 파일 확장자를 사용해야 합니다.

Capture

이제 3D 이미지를 캡처할 수 있습니다. 단일 획득 또는 다중 획득(HDR)이 있는지 여부는 settings 의 acquisitions 수에 따라 결정됩니다.

C++

source

const auto frame = camera.capture(settings);

C#

source

using (var frame = camera.Capture(settings))

Python

source

with camera.capture(settings) as frame:

C++

Zivid::Frame 포인트 클라우드 및 컬러 이미지(컴퓨팅 장치 메모리에 저장됨)와 캡처 및 카메라 정보가 포함됩니다.

C#

Zivid.NET.Frame 포인트 클라우드 및 컬러 이미지(컴퓨팅 장치 메모리에 저장됨)와 캡처 및 카메라 정보가 포함됩니다.

Python

zivid.Frame 포인트 클라우드 및 컬러 이미지(컴퓨팅 장치 메모리에 저장됨)와 캡처 및 카메라 정보가 포함됩니다.

Load

프레임을 저장하면 ZDF 파일에서 로드할 수 있습니다.

C++

소스

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);

C#

소스

var dataFile =
    Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData) + "/Zivid/Zivid3D.zdf";
Console.WriteLine("Reading ZDF frame from file: " + dataFile);
var frame = new Zivid.NET.Frame(dataFile);

Python

소스

data_file = get_sample_data_path() / "Zivid3D.zdf"
print(f"Reading point cloud from file: {data_file}")
frame = zivid.Frame(data_file)

ZDF 파일에 저장하는 것은 튜토리얼 뒷부분에서 다룹니다.

Capture 2D

3D보다 빠른 2D 이미지만 캡처하려는 경우 2D API를 통해 캡처할 수 있습니다.

C++

소스

const auto frame2D = camera.capture(settings2D);

C#

소스

using (var frame2D = camera.Capture(settings2D))

Python

소스

with camera.capture(settings_2d) as frame_2d:

Save

이제 결과를 저장할 수 있습니다.

C++

source

const auto dataFile = "Frame.zdf";
frame.save(dataFile);

C#

source

var dataFile = "Frame.zdf";
frame.Save(dataFile);

Python

source

data_file = "Frame.zdf"
frame.save(data_file)

팁

Zivid Studio 에서 Frame.zdf 파일을 열고 볼 수 있습니다.

Export

API는 사용할 형식을 감지합니다. 지원되는 형식 목록은 Point Cloud 을 참조하십시오. 예를 들어 포인트 클라우드를 .ply 형식으로 내보낼 수 있습니다.

C++

source

const auto dataFilePLY = "PointCloud.ply";
frame.save(dataFilePLY);

C#

source

var dataFilePLY = "PointCloud.ply";
frame.Save(dataFilePLY);

Python

source

data_file_ply = "PointCloud.ply"
frame.save(data_file_ply)

Save 2D

3D 캡처에서 2D 컬러 이미지를 얻을 수 있습니다.

C++

const auto image = pointCloud.copyImageRGBA();

C#

var image = PointCloud.CopyImageRGBA();

2D 캡처는 또한 2D 컬러 이미지를 생성합니다.

C++

소스

const auto image = frame2D.imageRGBA();

C#

소스

var image = frame2D.ImageRGBA();

Python

소스

image = frame_2d.image_rgba()

그런 다음 2D 이미지를 저장할 수 있습니다.

C++

소스

const auto imageFile = "Image.png";
std::cout << "Saving 2D color image to file: " << imageFile << std::endl;
image.save(imageFile);

C#

소스

var imageFile = "Image.png";
Console.WriteLine("Saving 2D color image to file: {0}", imageFile);
image.Save(imageFile);

Python

소스

image_file = "Image.png"
print(f"Saving 2D color image to file: {image_file}")
image.save(image_file)

Multithreading

카메라 개체에 대한 작업은 스레드로부터 안전하지만 카메라 나열 및 카메라 연결과 같은 다른 작업은 순서대로 실행해야 합니다. 자세한 내용은 Multithreading 알아보십시오.

Conclusion

이 튜토리얼은 Zivid SDK를 사용하여 Zivid 카메라에 연결, 구성, 캡처 및 저장하는 방법을 보여줍니다.