Capture Tutorial

Introduction

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

For the corresponding API, see Camera Basic.

Prerequisites

Initialize

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

참고

Application must be kept alive while operating the Zivid Camera. This is essentially the Zivid driver.

소스로 이동

소스

Zivid::Application zivid;
소스로 이동

소스

var zivid = new Zivid.NET.Application();
소스로 이동

소스

app = zivid.Application()

Connect

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

소스로 이동

source

auto camera = zivid.connectCamera();
소스로 이동

source

var camera = zivid.ConnectCamera();
소스로 이동

source

camera = app.connect_camera()

Specific Camera

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

소스로 이동

source

auto camera = zivid.connectCamera(Zivid::CameraInfo::SerialNumber{ "2020C0DE" });
소스로 이동

source

var camera = zivid.ConnectCamera("2020C0DE");
소스로 이동

source

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

참고

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

It is also possible to connect to a camera directly by its IP address or hostname. This bypasses mDNS discovery, which is useful when the camera is on a non-default subnet, when mDNS is blocked, or when you otherwise want to connect without relying on discovery.

소스로 이동

source

auto camera = zivid.connectCamera(Zivid::CameraAddress{ "172.28.60.5" });
소스로 이동

source

var camera = zivid.ConnectCamera(new Zivid.NET.CameraAddress("172.28.60.5"));
소스로 이동

source

camera = app.connect_camera(address=zivid.CameraAddress("172.28.60.5"))

The camera’s default hostname follows the format zivid-<serial-number>.local. It is not possible to get or set the hostname through the SDK. To do so, use the ZividNetworkCameraConfigurator CLI tool, as described in DHCP or Link Local IP Network Configuration - Camera.

소스로 이동

source

auto camera = zivid.connectCamera(Zivid::CameraAddress{ "zivid-2020C0DE.local" });
소스로 이동

source

var camera = zivid.ConnectCamera(new Zivid.NET.CameraAddress("zivid-2020C0DE.local"));
소스로 이동

source

camera = app.connect_camera(address=zivid.CameraAddress("zivid-2020C0DE.local"))

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

소스로 이동

소스

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;
}
소스로 이동

소스

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

소스

cameras = app.cameras()
for camera in cameras:
    print(camera.info)
    print(camera.state)

Configure

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

Presets

Zivid Studio에서 제공하는 Presets 을 사용하거나 .yml 파일로 제공하는 것을 권장합니다(아래 참조). 프리셋은 대부분의 경우 바로 사용할 수 있도록 설계되어 있어 시작하기에 좋습니다. 필요한 경우 설정을 쉽게 미세 조정하여 더 나은 결과를 얻을 수 있습니다. YAML 파일은 모든 텍스트 편집기에서 편집하거나 설정을 수동으로 코딩할 수 있습니다.

Load

Zivid Studio에서 카메라 설정을 .yml 파일로 내보낼 수 있습니다. 이 설정은 API에서 로드하여 적용할 수 있습니다.

소스로 이동

source

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

source

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

source

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

Save

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

소스로 이동

source

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

source

var settingsFile = "Settings.yml";
Console.WriteLine("Saving settings to file: " + settingsFile);
settings.Save(settingsFile);
소스로 이동

source

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

Manual configuration

또 다른 옵션은 설정을 수동으로 구성하는 것입니다. 각 설정의 기능에 대한 자세한 내용은 Camera Settings 을 참조하세요. 그 다음 단계는 Capturing High Quality Point Clouds 입니다.

Single 2D and 3D Acquisition - Default settings

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

소스로 이동

source

const auto settings =
    Zivid::Settings{ Zivid::Settings::Acquisitions{ Zivid::Settings::Acquisition{} },
                     Zivid::Settings::Color{ Zivid::Settings2D{
                         Zivid::Settings2D::Acquisitions{ Zivid::Settings2D::Acquisition{} } } } };
소스로 이동

source

var settings = new Zivid.NET.Settings
{
    Acquisitions = { new Zivid.NET.Settings.Acquisition { } },
    Color = new Zivid.NET.Settings2D { Acquisitions = { new Zivid.NET.Settings2D.Acquisition { } } }
};
소스로 이동

source

settings = zivid.Settings(
    acquisitions=[zivid.Settings.Acquisition()],
    color=zivid.Settings2D(acquisitions=[zivid.Settings2D.Acquisition()]),
)

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

Fully Configured Settings

색상 균형 및 감마와 같은 2D 설정은 수동으로 구성됩니다.

소스로 이동

source

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,
};
소스로 이동

source

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 },
        },
    },
};
소스로 이동

source

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 설정:

소스로 이동

source

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;
소스로 이동

source

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);
소스로 이동

source


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)

이미지 획득별로 다른 값이 가능합니다.

소스로 이동

source

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);
소스로 이동

source

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;
소스로 이동

source

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)

Capture 2D3D

이제 2D 및 3D 이미지(컬러 포인트 클라우드)를 캡처할 수 있습니다. 단일 획득인지 다중 획득인지(HDR)는 settingsacquisitions 횟수에 따라 결정됩니다.

소스로 이동

source

const auto frame = camera.capture2D3D(settings);
소스로 이동

source

using (var frame = camera.Capture2D3D(settings))
소스로 이동

source


frame = camera.capture_2d_3d(settings)

The Frame contains the point cloud, the color image, the capture, and the camera information (all of which are stored on the compute device memory).

The Frame contains the point cloud, the color image, the capture, and the camera information (all of which are stored on the compute device memory).

zivid.Frame 에는 포인트 클라우드, 컬러 이미지, 캡처, 카메라 정보가 포함되어 있으며, 이 모든 정보는 컴퓨팅 장치 메모리에 저장됩니다.

Capture 3D

색상이 없는 3D 포인트 클라우드만 캡처하려면 capture3D API를 사용하면 됩니다.

소스로 이동

source

const auto frame3D = camera.capture3D(settings);
소스로 이동

source

using (var frame3D = camera.Capture3D(settings))
소스로 이동

source

frame_3d = camera.capture_3d(settings)

Capture 2D

3D보다 빠른 2D 이미지만 캡처하고 싶은 경우 capture2D API를 사용하면 됩니다.

소스로 이동

source

const auto frame2D = camera.capture2D(settings);
소스로 이동

source

using (var frame2D = camera.Capture2D(settings))
소스로 이동

source

frame_2d = camera.capture_2d(settings)

Save

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

소스로 이동

source

const auto dataFile = "Frame.zdf";
frame.save(dataFile);
소스로 이동

source

var dataFile = "Frame.zdf";
frame.Save(dataFile);
소스로 이동

source

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

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

Export

다음 코드 예제에서는 포인트 클라우드를 .ply 형식으로 내보냅니다. 다른 내보내기 옵션은 Point Cloud 에서 지원되는 형식 목록을 참조하세요.

소스로 이동

source

const auto dataFilePLY = "PointCloud.ply";
frame.save(dataFilePLY);
소스로 이동

source

var dataFilePLY = "PointCloud.ply";
frame.Save(dataFilePLY);
소스로 이동

source

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

Load

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

소스로 이동

source

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);
소스로 이동

source

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

using (var frame = new Zivid.NET.Frame(dataFile))
{
소스로 이동

source

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

frame = zivid.Frame(data_file)

Save 2D

From a capture2D() you get a Frame2D. There are two color spaces available for 2D images: linear RGB and sRGB. The 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

소스로 이동

source

const auto imageRGBA = frame2D.imageRGBA();
소스로 이동

source

var imageRGBA = frame2D.ImageRGBA();
소스로 이동

source

image_rgba = frame_2d.image_rgba()

소스로 이동

source

const auto imageSRGB = frame2D.imageRGBA_SRGB();
소스로 이동

source

var imageSRGB = frame2D.ImageRGBA_SRGB();
소스로 이동

source

image_srgb = frame_2d.image_rgba_srgb()

그러면 2D 이미지를 선형 RGB 또는 sRGB 색상 공간에 저장할 수 있습니다.

소스로 이동

source

const auto imageFile = "ImageRGBA_linear.png";
std::cout << "Saving 2D color image (Linear RGB) to file: " << imageFile << std::endl;
imageRGBA.save(imageFile);
소스로 이동

source

var imageFile = "ImageRGBA_linear.png";
Console.WriteLine($"Saving 2D color image (Linear RGB) to file: {imageFile}");
imageRGBA.Save(imageFile);
소스로 이동

source

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

소스로 이동

source

const auto imageFile = "ImageRGBA_sRGB.png";
std::cout << "Saving 2D color image (sRGB color space) to file: " << imageFile << std::endl;
imageSRGB.save(imageFile);
소스로 이동

source

var imageFile = "ImageRGBA_sRGB.png";
Console.WriteLine($"Saving 2D color image (sRGB color space) to file: {imageFile}");
imageSRGB.Save(imageFile);
소스로 이동

source

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

포인트 클라우드에서 직접 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 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()

File Camera

file camera 를 사용하면 실제 카메라에 접근하지 않고도 SDK를 실험해 볼 수 있습니다. 파일 카메라는 Sample Data 에서 찾을 수 있으며, 여러 파일 카메라 중에서 선택할 수 있습니다.

소스로 이동

source

const auto fileCamera =
    userInput ? fileCameraPath : std::string(ZIVID_SAMPLE_DATA_DIR) + "/FileCameraZivid2PlusMR60.zfc";
소스로 이동

source

fileCamera = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData) + "/Zivid/FileCameraZivid2PlusMR60.zfc";
소스로 이동

source

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

소스로 이동

source

std::cout << "Creating virtual camera using file: " << fileCamera << std::endl;
auto camera = zivid.createFileCamera(fileCamera);
소스로 이동

source

Console.WriteLine("Creating virtual camera using file: " + fileCamera);
var camera = zivid.CreateFileCamera(fileCamera);
소스로 이동

source

print(f"Creating virtual camera using file: {file_camera}")
camera = app.create_file_camera(file_camera)

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

소스로 이동

source

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 };
소스로 이동

source

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;
소스로 이동

source

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 에서 확인할 수 있습니다.

Multithreading

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

Conclusion

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

For the corresponding API, see Camera Basic.

Version History

SDK

Changes

2.18.0

Added connecting to a camera by IP address or hostname.