← Back to Skills Marketplace
wangyendt

Pywayne Cv Camera Model

by wangyendt · GitHub ↗ · v0.1.0
cross-platform ⚠ suspicious
556
Downloads
0
Stars
0
Active Installs
1
Versions
Install in OpenClaw
/install camera-model
Description
Camera model wrapper for camera_models C++ library via pybind11. Use when working with pywayne.cv.camera_model module to load camera models from YAML configu...
README (SKILL.md)

Pywayne Camera Model

This module wraps the camera_models C++ library via pybind11, providing a Python interface for camera operations.

Quick Start

from pywayne.cv.camera_model import CameraModel
from pywayne.cv.tools import write_cv_yaml
import numpy as np

# Create camera model
camera = CameraModel()

# Load from YAML file
camera.load_from_yaml('camera_config.yaml')

# Access properties
print(f"Model: {camera.model_type}")
print(f"Size: {camera.image_width}x{camera.image_height}")

Loading from YAML

from pathlib import Path

# Sample YAML configuration
yaml_data = {
    "model_type": "PINHOLE",
    "camera_name": "my_camera",
    "image_width": 1280,
    "image_height": 720,
    "distortion_parameters": {"k1": 0.0, "k2": 0.0},
    "projection_parameters": {"fx": 600.0, "fy": 600.0, "cx": 640.0, "cy": 360.0}
}

# Write YAML file
write_cv_yaml('camera_config.yaml', yaml_data)

# Load model
camera.load_from_yaml('camera_config.yaml')

Supported Camera Models

Model Type Description
PINHOLE Standard pinhole camera with radial distortion
PINHOLE_FULL Full pinhole model with all distortion parameters
CATA Catadioptric camera model
EQUIDISTANT Equidistant camera model
OCAM Unified camera model

Projection Operations

lift_projective()

Lifts a 2D image point to a 3D projective ray:

# Input can be tuple, list, or numpy array
ray_3d = camera.lift_projective([u, v])  # Returns np.ndarray (x, y, z)

space_to_plane()

Projects a 3D point onto the 2D image plane:

# Input can be tuple, list, or numpy array
uv = camera.space_to_plane([x, y, z])  # Returns np.ndarray (u, v)

Properties

Property Description
model_type Camera model type (enum)
camera_name Name of the loaded camera
image_width Image width in pixels
image_height Image height in pixels

Parameters Dictionary

Export all camera parameters as a dictionary:

params = camera.get_parameters_as_dict()
print(params)

Includes model-specific parameters:

  • Pinhole: k1, k2, p1, p2, fx, fy, cx, cy
  • Pinhole Full: k1-k6, p1-p2, fx, fy, cx, cy
  • CATA: xi, k1-k2, p1-p2, gamma1-2, u0, v0
  • Equidistant: k2-k5, mu, mv, u0, v0
  • OCAM: C, D, E, center_x, center_y, poly, inv_poly

Requirements

  • camera_models - C++ library (auto-downloaded via gettool if missing)
  • numpy - Array operations
  • pywayne.cv.tools.write_cv_yaml - For writing YAML files

Notes

  • Library is automatically checked and downloaded via gettool if not found
  • Supports both tuple/list and numpy array inputs for projection methods
  • Output from projection methods is always np.ndarray with dtype=np.float64
Usage Guidance
This skill is essentially documentation for using a pybind11-wrapped C++ camera module. The main risk is the line 'auto-downloaded via gettool if missing' — the skill gives the agent discretion to install native code but does not specify what will be downloaded or from where. Before installing or enabling this skill: 1) Confirm whether your platform provides a trusted 'gettool' and what sources it uses; 2) If you run on an environment that must have the native module preinstalled, verify camera_models/pywayne are installed from trusted packages; 3) Avoid allowing the agent to perform unspecified downloads or installs unless you trust the repository and have visibility into the download URLs and checksums. Providing an explicit install spec (trusted release URL, package name, or declared required binary) would reduce the ambiguity and lower risk.
Capability Analysis
Type: OpenClaw Skill Name: camera-model Version: 0.1.0 The skill bundle describes a Python wrapper for a C++ camera model library. The `SKILL.md` provides clear, functional instructions and code examples for using the library, without any evidence of prompt injection attempts against the AI agent. Dependencies are managed via the platform's `gettool` mechanism, and there are no indications of malicious file operations, network activity, data exfiltration, or persistence mechanisms within the provided content. The functionality aligns with a standard computer vision utility.
Capability Assessment
Purpose & Capability
The name/description match the instructions: this is a wrapper for a C++ camera_models library exposed to Python. Declared runtime dependencies (camera_models, numpy) are consistent with the purpose. However, the skill provides no code or binary and relies on a preinstalled or dynamically fetched native module; that expectation is not documented in the registry metadata (no install spec, no required binaries).
Instruction Scope
SKILL.md stays within the camera-model domain for examples and API usage, but it explicitly says the library is 'automatically checked and downloaded via gettool if not found'. That gives the agent open-ended authority to fetch and install native code at runtime without specifying what to download or from where, which is vague and could lead to arbitrary network fetches and disk writes.
Install Mechanism
No install spec is present in the registry metadata, yet the instructions reference a runtime installer ('gettool'). The absence of a declared install method, URLs, or required binary for gettool is an inconsistency: either the platform provides a trusted gettool (not declared) or the agent is expected to fetch arbitrary artifacts — the doc doesn't clarify which.
Credentials
The skill does not request any environment variables, credentials, or config paths. The stated dependencies (camera_models, numpy) are proportional to the camera-model purpose.
Persistence & Privilege
always is false and there is no instruction to modify other skills or system-wide settings. Autonomous invocation is allowed (platform default) but does not combine with other red flags here.
How to Use
  1. Make sure OpenClaw is installed (local or Docker)
  2. Run the install command in chat: /install camera-model
  3. After installation, invoke the skill by name or use /camera-model
  4. Provide required inputs per the skill's parameter spec and get structured output
Version History
v0.1.0
Initial release of pywayne-cv-camera-model: a Python wrapper for the camera_models C++ library. - Load camera models from YAML configuration files. - Access camera properties such as model type, image size, and camera parameters. - Perform 2D/3D projection operations: `lift_projective` and `space_to_plane`. - Export camera parameters as dictionaries for further use. - Supports multiple standard and advanced camera models.
Metadata
Slug camera-model
Version 0.1.0
License
All-time Installs 0
Active Installs 0
Total Versions 1
Frequently Asked Questions

What is Pywayne Cv Camera Model?

Camera model wrapper for camera_models C++ library via pybind11. Use when working with pywayne.cv.camera_model module to load camera models from YAML configu... It is an AI Agent Skill for Claude Code / OpenClaw, with 556 downloads so far.

How do I install Pywayne Cv Camera Model?

Run "/install camera-model" in the OpenClaw or Claude Code chat to install it in one step — no extra setup required.

Is Pywayne Cv Camera Model free?

Yes, Pywayne Cv Camera Model is completely free (open-source). You can download, install and use it at no cost.

Which platforms does Pywayne Cv Camera Model support?

Pywayne Cv Camera Model is cross-platform and runs anywhere OpenClaw / Claude Code is available (cross-platform).

Who created Pywayne Cv Camera Model?

It is built and maintained by wangyendt (@wangyendt); the current version is v0.1.0.

💬 Comments