Micro-Epsilon:scanCONTROL:PythonWrapper

import ctypes as ct
import pymegc as megc

# 1. 시스템 초기화 및 장치 검색
sys_obj = megc.megc_system_t()
megc.SysInit(ct.byref(sys_obj))
megc.SysFindDevices(ct.byref(sys_obj))

# 2. 장치 정보 조회
device_count = megc.SysGetDeviceCount(ct.byref(sys_obj))
device = megc.SysGetDevice(ct.byref(sys_obj), 0)

# 3. MEGC 클라이언트 초기화 및 연결
megc_obj = megc.megc_t()
megc.Init(ct.byref(megc_obj))
megc.ConnectByDevice(ct.byref(megc_obj), device)

# 4. 파라미터 설정
params = megc.GetDeviceParams(ct.byref(megc_obj))
param = megc.ParamsGetParamByName(params, b"ExposureTime")
megc.ParamSetFloatValue(param, ct.c_double(100.0))

# 5. 컴포넌트 설정 및 획득 시작
# ... (측정 유형에 따라 다름)

# 6. 데이터 획득 (콜백 또는 폴링)
# ... (아래 상세 설명 참조)

# 7. 정리
megc.AcquisitionStop(ct.byref(megc_obj))
megc.Disconnect(ct.byref(megc_obj))
megc.Destroy(ct.byref(megc_obj))
megc.SysDestroy(ct.byref(sys_obj))

# 장치 모델명 조회
buffer_size = ct.c_ulong(256)
buffer = ct.create_string_buffer(256)
megc.DeviceGetModelName(device, buffer, ct.byref(buffer_size))
print(f"모델명: {buffer.value.decode()}")

# 장치 시리얼 번호 조회
megc.DeviceGetSerialNumber(device, buffer, ct.byref(buffer_size))
print(f"시리얼: {buffer.value.decode()}")

# IP 주소 조회
megc.DeviceGetIPAddress(device, buffer, ct.byref(buffer_size))
print(f"IP: {buffer.value.decode()}")

# 파라미터 컬렉션 가져오기
params = megc.GetDeviceParams(ct.byref(megc_obj))
param_count = megc.GetDeviceParamsCount(ct.byref(megc_obj))

# 이름으로 파라미터 가져오기
param = megc.ParamsGetParamByName(params, b"ExposureTime")

# Float 값 읽기
value = ct.c_double()
megc.ParamGetFloatValue(param, ct.byref(value))
print(f"노출 시간: {value.value}")

# Float 범위 조회
min_val = ct.c_double()
max_val = ct.c_double()
megc.ParamGetFloatMinMaxValues(param, ct.byref(min_val), ct.byref(max_val))
print(f"범위: {min_val.value} ~ {max_val.value}")

# Float 값 쓰기
megc.ParamSetFloatValue(param, ct.c_double(200.0))

# Integer 파라미터 예시
param_width = megc.ParamsGetParamByName(params, b"Width")
int_value = ct.c_longlong()
megc.ParamGetIntegerValue(param_width, ct.byref(int_value))
print(f"Width: {int_value.value}")

# Enum 파라미터 예시
param_trigger = megc.ParamsGetParamByName(params, b"TriggerMode")
megc.ParamSetEnumValueByName(param_trigger, b"On")

# 단일 이미지 콜백
@ct.CFUNCTYPE(None, ct.POINTER(megc.meg_image_t), ct.c_void_p)
def image_callback(image, user_data):
    # 이미지 처리 로직
    pass

# 이미지 벡터 콜백
@ct.CFUNCTYPE(None, ct.POINTER(megc.meg_image_vec_t), ct.c_void_p)
def image_vec_callback(image_vec, user_data):
    # 복수 이미지 처리 로직
    pass

# 이미지 벡터 초기화
image_vec = megc.meg_image_vec_t()
megc.ImageVecInitEmpty(ct.byref(image_vec))

# 타임아웃(밀리초)으로 이미지 대기
status = megc.PollImages(ct.byref(megc_obj), ct.byref(image_vec), 20000, None)

if megc.MEGC_STATUS_IS_OK(status):
    # 이미지 처리
    pass

# 정리
megc.ImageVecDestroy(ct.byref(image_vec))

# meg_abc32f_t 구조체 필드
# .a = X 좌표 (float32)
# .b = Y 좌표 (float32)
# .c = Z 좌표 (float32)

# 3D 이미지 데이터 접근 예시
data_ptr = ct.cast(image.contents.data, ct.POINTER(megc.meg_abc32f_t))
width = image.contents.width
height = image.contents.height

for row in range(height):
    for col in range(width):
        idx = row * width + col
        x = data_ptr[idx].a
        y = data_ptr[idx].b
        z = data_ptr[idx].c
        if not math.isnan(x):  # 유효한 포인트만 처리
            print(f"X={x:.3f}, Y={y:.3f}, Z={z:.3f}")

# meg_ac32f_t 구조체 필드
# .a = X 좌표/진폭 (float32)
# .c = Z 좌표/거리 (float32)

# 2D 프로파일 데이터 접근 예시
data_ptr = ct.cast(image.contents.data, ct.POINTER(megc.meg_ac32f_t))
width = image.contents.width

for col in range(width):
    x = data_ptr[col].a
    z = data_ptr[col].c
    if not math.isnan(x):
        print(f"X={x:.3f}, Z={z:.3f}")

# 접근 타입 확인
access_type = megc.GetAccessTypeByIPAddress(b"192.168.1.100")
if access_type == megc.MEGC_ACCESS_TYPE_CONTROL:
    print("다른 클라이언트가 제어 중 - 읽기 전용 모드로 연결")

# 읽기 전용 모드로 설정 (포트 1042: 멀티캐스트 수신)
megc.SetAccessReadOnly(ct.byref(megc_obj), 1042)

# 또는 제어 모드로 전환
megc.SetAccessControl(ct.byref(megc_obj))

# 읽기 전용 여부 확인
is_readonly = megc.IsAccessReadOnly(ct.byref(megc_obj))

status = megc.ConnectByIPAddress(ct.byref(megc_obj), b"192.168.1.100")
if megc.MEGC_STATUS_IS_ERR(status):
    error_msg = megc.GetErrorMessage(status)
    print(f"오류 ({status}): {error_msg}")

import ctypes as ct
import pymegc as megc

# 시스템 초기화
megc_sys = megc.megc_system_t()
status = megc.SysInit(ct.byref(megc_sys))
if megc.MEGC_STATUS_IS_ERR(status):
    print("시스템 초기화 실패")
    exit(1)

# 장치 검색
megc.SysFindDevices(ct.byref(megc_sys))
device_count = megc.SysGetDeviceCount(ct.byref(megc_sys))
print(f"검색된 장치 수: {device_count}")

# 각 장치 정보 출력
buffer_size = ct.c_ulong(256)
buffer = ct.create_string_buffer(256)

for i in range(device_count):
    device = megc.SysGetDevice(ct.byref(megc_sys), i)

    buffer_size.value = 256
    megc.DeviceGetModelName(device, buffer, ct.byref(buffer_size))
    model = buffer.value.decode()

    buffer_size.value = 256
    megc.DeviceGetSerialNumber(device, buffer, ct.byref(buffer_size))
    serial = buffer.value.decode()

    buffer_size.value = 256
    megc.DeviceGetIPAddress(device, buffer, ct.byref(buffer_size))
    ip = buffer.value.decode()

    print(f"  [{i}] {model} (S/N: {serial}, IP: {ip})")

# 정리
megc.SysDestroy(ct.byref(megc_sys))

import ctypes as ct
import pymegc as megc
import math
import time

# --- 콜백 함수 정의 ---
received_count = 0

@ct.CFUNCTYPE(None, ct.POINTER(megc.meg_image_t), ct.c_void_p)
def on_image(image, user_data):
    global received_count
    received_count += 1

    img = image.contents
    if img.type == megc.MEG_PIX_ABC32F:
        data = ct.cast(img.data, ct.POINTER(megc.meg_abc32f_t))
        valid_points = 0

        for i in range(img.width * img.height):
            if not math.isnan(data[i].a):
                valid_points += 1

        print(f"프레임 #{received_count}: {img.width}x{img.height}, "
              f"유효 포인트: {valid_points}")

# --- 메인 로직 ---
# 시스템 초기화 및 장치 검색
megc_sys = megc.megc_system_t()
megc.SysInit(ct.byref(megc_sys))
megc.SysFindDevices(ct.byref(megc_sys))

if megc.SysGetDeviceCount(ct.byref(megc_sys)) == 0:
    print("장치를 찾을 수 없습니다")
    megc.SysDestroy(ct.byref(megc_sys))
    exit(1)

device = megc.SysGetDevice(ct.byref(megc_sys), 0)

# MEGC 클라이언트 연결
megc_obj = megc.megc_t()
megc.Init(ct.byref(megc_obj))
megc.ConnectByDevice(ct.byref(megc_obj), device)

# 파라미터 설정
params = megc.GetDeviceParams(ct.byref(megc_obj))

# 노출 시간 설정
param = megc.ParamsGetParamByName(params, b"ExposureTime")
if param:
    megc.ParamSetFloatValue(param, ct.c_double(100.0))

# 트리거 모드 설정
param = megc.ParamsGetParamByName(params, b"TriggerMode")
if param:
    megc.ParamSetEnumValueByName(param, b"On")

# 3D 컴포넌트 활성화 (MEG_PIX_ABC32F)
comp_count = megc.GetComponentCount(ct.byref(megc_obj))
for i in range(comp_count):
    comp = megc.GetComponent(ct.byref(megc_obj), i)
    if comp and comp.contents.type == megc.MEG_PIX_ABC32F:
        megc.ComponentEnable(ct.byref(megc_obj), comp, 1)
        break

# 콜백 등록 및 획득 시작
megc.SetImageCallback(ct.byref(megc_obj), on_image, None)
megc.AcquisitionStart(ct.byref(megc_obj))

# 소프트웨어 트리거로 데이터 요청
for i in range(5):
    megc.TriggerSoftware(ct.byref(megc_obj))
    time.sleep(1)

# 정리
megc.AcquisitionStop(ct.byref(megc_obj))
megc.Disconnect(ct.byref(megc_obj))
megc.Destroy(ct.byref(megc_obj))
megc.SysDestroy(ct.byref(megc_sys))
print(f"총 수신 프레임: {received_count}")

import ctypes as ct
import pymegc as megc
import math

# 시스템 초기화 및 연결
megc_sys = megc.megc_system_t()
megc.SysInit(ct.byref(megc_sys))
megc.SysFindDevices(ct.byref(megc_sys))

device = megc.SysGetDevice(ct.byref(megc_sys), 0)

megc_obj = megc.megc_t()
megc.Init(ct.byref(megc_obj))
megc.ConnectByDevice(ct.byref(megc_obj), device)

# 파라미터 설정
params = megc.GetDeviceParams(ct.byref(megc_obj))
param = megc.ParamsGetParamByName(params, b"ExposureTime")
if param:
    megc.ParamSetFloatValue(param, ct.c_double(100.0))

# 2D 컴포넌트 활성화 (MEG_PIX_AC32F)
comp_count = megc.GetComponentCount(ct.byref(megc_obj))
for i in range(comp_count):
    comp = megc.GetComponent(ct.byref(megc_obj), i)
    if comp and comp.contents.type == megc.MEG_PIX_AC32F:
        megc.ComponentEnable(ct.byref(megc_obj), comp, 1)
        break

# 이미지 벡터 초기화
image_vec = megc.meg_image_vec_t()
megc.ImageVecInitEmpty(ct.byref(image_vec))

# 획득 시작
megc.Start(ct.byref(megc_obj))

# 폴링으로 이미지 수신 (타임아웃: 20초)
for frame in range(5):
    status = megc.PollImages(ct.byref(megc_obj), ct.byref(image_vec), 20000, None)

    if megc.MEGC_STATUS_IS_OK(status):
        # 이미지 벡터에서 데이터 추출
        for j in range(image_vec.count):
            img = image_vec.images[j]
            if img.type == megc.MEG_PIX_AC32F:
                data = ct.cast(img.data, ct.POINTER(megc.meg_ac32f_t))
                print(f"프레임 #{frame}: 너비={img.width}")

                # 처음 5개 포인트 출력
                for k in range(min(5, img.width)):
                    x = data[k].a
                    z = data[k].c
                    if not math.isnan(x):
                        print(f"  포인트[{k}]: X={x:.3f}, Z={z:.3f}")
    else:
        print(f"폴링 실패: {status}")

# 정리
megc.Stop(ct.byref(megc_obj))
megc.ImageVecDestroy(ct.byref(image_vec))
megc.Disconnect(ct.byref(megc_obj))
megc.Destroy(ct.byref(megc_obj))
megc.SysDestroy(ct.byref(megc_sys))

import ctypes as ct
import pymegc as megc

# 연결 (생략: 위 예제 참조)
# ...

params = megc.GetDeviceParams(ct.byref(megc_obj))
param_count = megc.GetDeviceParamsCount(ct.byref(megc_obj))

buffer_size = ct.c_ulong(256)
buffer = ct.create_string_buffer(256)

for i in range(param_count):
    param = megc.ParamsGetParam(params, i)
    param_type = megc.ParamGetType(param)

    buffer_size.value = 256
    megc.ParamGetName(param, buffer, ct.byref(buffer_size))
    name = buffer.value.decode()

    # 읽기 가능한 파라미터만 값 표시
    if not megc.ParamIsReadable(param):
        print(f"  {name}: [읽기 불가]")
        continue

    if param_type == megc.MEG_PARAM_BOOLEAN:
        val = ct.c_ubyte()
        megc.ParamGetBooleanValue(param, ct.byref(val))
        print(f"  {name} (Boolean): {bool(val.value)}")

    elif param_type == megc.MEG_PARAM_INTEGER:
        val = ct.c_longlong()
        megc.ParamGetIntegerValue(param, ct.byref(val))
        min_v, max_v, inc = ct.c_longlong(), ct.c_longlong(), ct.c_longlong()
        megc.ParamGetIntegerMinMaxIncValues(param, ct.byref(min_v), ct.byref(max_v), ct.byref(inc))
        print(f"  {name} (Integer): {val.value} [{min_v.value}..{max_v.value}, step={inc.value}]")

    elif param_type == megc.MEG_PARAM_FLOAT:
        val = ct.c_double()
        megc.ParamGetFloatValue(param, ct.byref(val))
        min_v, max_v = ct.c_double(), ct.c_double()
        megc.ParamGetFloatMinMaxValues(param, ct.byref(min_v), ct.byref(max_v))
        print(f"  {name} (Float): {val.value} [{min_v.value}..{max_v.value}]")

    elif param_type == megc.MEG_PARAM_ENUM:
        val = ct.c_longlong()
        megc.ParamGetEnumValue(param, ct.byref(val))
        buffer_size.value = 256
        megc.ParamGetEnumStringValue(param, buffer, ct.byref(buffer_size))
        print(f"  {name} (Enum): {buffer.value.decode()} ({val.value})")

    elif param_type == megc.MEG_PARAM_STRING:
        buffer_size.value = 256
        megc.ParamGetStringValue(param, buffer, ct.byref(buffer_size))
        print(f"  {name} (String): {buffer.value.decode()}")

import ctypes as ct
import pymegc as megc

device_ip = b"192.168.1.100"

# 접근 타입 확인
access_type = megc.GetAccessTypeByIPAddress(device_ip)
print(f"접근 타입: {access_type}")

if access_type == megc.MEGC_ACCESS_TYPE_OPEN:
    print("장치가 사용 가능합니다 - 제어 모드로 연결")
elif access_type == megc.MEGC_ACCESS_TYPE_CONTROL:
    print("다른 클라이언트가 제어 중 - 읽기 전용으로 연결")

# 클라이언트 초기화 및 읽기 전용 설정
megc_obj = megc.megc_t()
megc.Init(ct.byref(megc_obj))
megc.SetAccessReadOnly(ct.byref(megc_obj), 1042)  # 멀티캐스트 포트
megc.ConnectByIPAddress(ct.byref(megc_obj), device_ip)

# 콜백 등록 후 데이터 수신
megc.SetImageCallback(ct.byref(megc_obj), on_image, None)
megc.Start(ct.byref(megc_obj))

# ... 데이터 수신 대기 ...

# 정리
megc.Stop(ct.byref(megc_obj))
megc.Disconnect(ct.byref(megc_obj))
megc.Destroy(ct.byref(megc_obj))

# 멀티캐스트 대상 주소 및 포트 설정
megc.SetStreamDestination(ct.byref(megc_obj), b"239.1.1.1", 1042)