Micro-Epsilon:scanCONTROL

# LVS 프로파일 → 3D 포인트 클라우드 변환 예시
# LVS profile → 3D point cloud conversion example

import numpy as np

def profiles_to_pointcloud(profiles: list[dict], y_step_mm: float) -> np.ndarray:
    """
    profiles: [{'x': np.array, 'z': np.array, 'intensity': np.array}, ...]
    y_step_mm: 각 프로파일 간 Y 이동 거리 (mm)
    반환: (N, 4) 배열 [x, y, z, intensity]
    """
    points = []
    for i, prof in enumerate(profiles):
        x = prof['x']                          # X 좌표 배열 (mm)
        z = prof['z']                          # Z 높이 배열 (mm)
        y = np.full_like(x, i * y_step_mm)    # Y는 이동 거리로 계산
        intensity = prof['intensity'].astype(np.float32)

        # 유효 포인트만 필터링 (Filter valid points only)
        valid = np.isfinite(x) & np.isfinite(z) & (z > -32767)
        pts = np.stack([x[valid], y[valid], z[valid], intensity[valid]], axis=-1)
        points.append(pts)

    return np.concatenate(points, axis=0)  # shape: (N, 4)

# scanCONTROL SDK Python 연동 예시 (ctypes 기반)
# scanCONTROL SDK Python binding example via ctypes

import ctypes
import numpy as np

# DLL 로드 (Load DLL)
llt = ctypes.WinDLL("LLT.dll")

HANDLE = ctypes.c_void_p
N_POINTS = 1280  # 센서 해상도에 따라 변경

def get_profile(handle: HANDLE) -> dict:
    """
    단일 프로파일 취득 (Get single profile)
    Returns: {'x': np.array, 'z': np.array, 'intensity': np.array}
    """
    buf_size = N_POINTS * 10 + 16           # X(4) + Z(4) + Intensity(2) + Header
    buf = (ctypes.c_uint8 * buf_size)()

    ret = llt.GetActualProfile(handle, buf, buf_size)
    if ret < 0:
        raise RuntimeError(f"GetActualProfile 실패: {ret}")

    # 헤더 파싱 (Parse header)
    counter   = ctypes.c_uint32.from_buffer_copy(buf,  0).value
    timestamp = ctypes.c_uint32.from_buffer_copy(buf,  4).value  # ×10 µs
    encoder   = ctypes.c_int32.from_buffer_copy(buf,   8).value

    # 데이터 추출 (Extract data arrays)
    x   = np.frombuffer(buf, dtype=np.float32, count=N_POINTS, offset=16)
    z   = np.frombuffer(buf, dtype=np.float32, count=N_POINTS, offset=16 + N_POINTS*4)
    inten = np.frombuffer(buf, dtype=np.uint16, count=N_POINTS, offset=16 + N_POINTS*8)

    return {
        'counter':   counter,
        'timestamp': timestamp * 1e-5,      # 초 단위 변환 (convert to seconds)
        'encoder':   encoder,
        'x':         x.copy(),
        'z':         z.copy(),
        'intensity': inten.copy()
    }

# LVS 데이터 전처리 파이프라인
# LVS data preprocessing pipeline

import numpy as np
import cv2

class LVSPreprocessor:
    """
    LVS 프로파일 데이터 전처리기
    LVS profile data preprocessor
    """
    def __init__(
        self,
        n_points: int = 1280,       # 프로파일 포인트 수
        n_profiles: int = 512,      # 수집할 프로파일 수 (Y 방향 길이)
        z_min: float = -5.0,        # Z 유효 범위 최솟값 (mm)
        z_max: float = 10.0,        # Z 유효 범위 최댓값 (mm)
    ):
        self.n_points = n_points
        self.n_profiles = n_profiles
        self.z_min = z_min
        self.z_max = z_max

    def build_depth_map(self, profiles: list[dict]) -> np.ndarray:
        """
        프로파일 리스트 → Depth Map (H × W) float32
        Profile list → Depth Map (H × W) float32
        """
        depth = np.full((self.n_profiles, self.n_points), np.nan, dtype=np.float32)
        for i, prof in enumerate(profiles[:self.n_profiles]):
            z = prof['z'].copy()
            # 범위 밖 값 무효 처리 (Invalidate out-of-range values)
            z[(z < self.z_min) | (z > self.z_max)] = np.nan
            depth[i] = z

        # NaN을 0으로 대체 후 정규화 (Replace NaN with 0, then normalize)
        valid_mask = np.isfinite(depth)
        depth = np.where(valid_mask, depth, 0.0)
        depth = (depth - self.z_min) / (self.z_max - self.z_min)   # [0, 1]
        depth = np.clip(depth, 0.0, 1.0)
        return depth  # shape: (H, W)

    def build_multichannel(self, profiles: list[dict]) -> np.ndarray:
        """
        프로파일 리스트 → 3채널 맵 (H × W × 3)
        Channel 0: Z (깊이), Channel 1: Intensity, Channel 2: X (가로 위치)
        """
        dm = self.build_depth_map(profiles)
        intensity_map = np.zeros((self.n_profiles, self.n_points), dtype=np.float32)
        x_map = np.zeros_like(intensity_map)

        for i, prof in enumerate(profiles[:self.n_profiles]):
            inten = prof['intensity'].astype(np.float32)
            intensity_map[i] = inten / 65535.0   # uint16 정규화
            x_map[i] = (prof['x'] - prof['x'].min()) / (prof['x'].ptp() + 1e-8)

        return np.stack([dm, intensity_map, x_map], axis=-1)   # (H, W, 3)

    def extract_bead_roi(
        self,
        depth_map: np.ndarray,
        roi_width_px: int = 200
    ) -> np.ndarray:
        """
        비드 중심 자동 감지 후 ROI 크롭
        Auto-detect bead center and crop ROI
        """
        # 열 방향 평균으로 비드 중심 추정 (Estimate bead center via column mean)
        col_mean = np.nanmean(depth_map, axis=0)
        center = int(np.argmax(col_mean))
        left  = max(0, center - roi_width_px // 2)
        right = min(depth_map.shape[1], left + roi_width_px)
        return depth_map[:, left:right]