Lerobot-Dataset-Ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 244035b2c7eb6cf559933949e548ad146bf5b5fc4f85741cc583d0d663f2df0a
+  data.tar.gz: 4ecb290a52027bb0d1c250a61f4a31474e95e290e39b79b59084ae913caa8c52
+SHA512:
+  metadata.gz: 2ffbe6e6b3c0a3b226eef5b065010b281b26ac7c6e98edca3519087d6ed018bac646ddb79472d06757a094d513d538c24cf148cff33aaac2a6b80dd0a87f8866
+  data.tar.gz: 677f955ef392be20c35159ca73d49d33b87578b16b2b144c8b944b4b6baf4c4e0b24934693284c35203984b887907470981090a3b266e367bae89421ff07b8c6

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-09-29
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"Lerobot-Dataset-Ruby" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at ["kimura_yuuto@it-mirai-h.ibk.ed.jp"](mailto:"kimura_yuuto@it-mirai-h.ibk.ed.jp").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 kimurayuuto-netizen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# Lerobot::Dataset::Ruby
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/Lerobot/Dataset/Ruby`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/Lerobot-Dataset-Ruby. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/Lerobot-Dataset-Ruby/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Lerobot::Dataset::Ruby project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/Lerobot-Dataset-Ruby/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+desc "Compile native extension"
+task :compile do
+  so_file = File.expand_path("ext/opencv/libopencv.so", __dir__)
+  unless File.exist?(so_file)
+    system("cd #{File.expand_path('ext/opencv', __dir__)} && ruby extconf.rb && make", exception: true)
+  end
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/test_*.rb"]
+end
+
+task test: :compile
+task default: :test

data/ext/opencv/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+dir_config("opencv")
+
+pkg_config('opencv4')
+create_header()
+create_makefile('libopencv')

data/ext/opencv/libopencv.cpp

@@ -0,0 +1,281 @@
+#include <opencv4/opencv2/videoio.hpp>
+#include <opencv4/opencv2/highgui.hpp>
+#include <opencv4/opencv2/core.hpp>
+#include <opencv4/opencv2/imgcodecs.hpp>
+#include <opencv4/opencv2/imgproc.hpp>
+
+
+#include <ruby.h>
+#include <stdlib.h>
+#include <cstdio>
+#include <string>
+#include <vector>
+
+cv::VideoCapture camera;
+cv::VideoWriter video_writer;
+cv::Mat frame; 
+bool debug_mode = false;
+bool recording = false;
+std::string recording_path;
+double recording_fps = 30.0;
+int camera_width = 0;
+int camera_height = 0;
+
+static VALUE open_camera_source(VALUE self, VALUE source, VALUE width, VALUE height) {
+    int w = NUM2INT(width);
+    int h = NUM2INT(height);
+    if (w <= 0 || h <= 0) {
+        rb_raise(rb_eArgError, "幅と高さは0より大きい値を指定してください。");
+        return Qfalse;
+    }
+
+    camera.release();
+    camera.open(NUM2INT(source));
+    debug_mode = false;
+
+    if (!camera.isOpened()) {
+        rb_raise(rb_eRuntimeError, "カメラの起動に失敗しました。");
+        return Qfalse;
+    }
+
+    camera.set(cv::CAP_PROP_FRAME_WIDTH, w);
+    camera.set(cv::CAP_PROP_FRAME_HEIGHT, h);
+
+    camera_width = static_cast<int>(camera.get(cv::CAP_PROP_FRAME_WIDTH));
+    camera_height = static_cast<int>(camera.get(cv::CAP_PROP_FRAME_HEIGHT));
+    if (camera_width <= 0 || camera_height <= 0) {
+        camera_width = w;
+        camera_height = h;
+    }
+
+    return Qtrue;
+}
+
+static VALUE open_mp4_source(VALUE self, VALUE path) {
+    if (NIL_P(path) || TYPE(path) != T_STRING || StringValueCStr(path)[0] == '\0') {
+        rb_raise(rb_eArgError, "MP4のパスを文字列で指定してください。");
+        return Qfalse;
+    }
+
+    camera.release();
+    camera.open(StringValueCStr(path));
+    debug_mode = true;
+
+    if (!camera.isOpened()) {
+        rb_raise(rb_eRuntimeError, "MP4動画の起動に失敗しました。");
+        return Qfalse;
+    }
+
+    camera_width = static_cast<int>(camera.get(cv::CAP_PROP_FRAME_WIDTH));
+    camera_height = static_cast<int>(camera.get(cv::CAP_PROP_FRAME_HEIGHT));
+
+    return Qtrue;
+}
+
+static VALUE start_recording(VALUE self, VALUE path, VALUE fps) {
+    if (recording) {
+        rb_raise(rb_eRuntimeError, "動画をすでに録画中です。");
+    }
+
+    if (NIL_P(path) || TYPE(path) != T_STRING || StringValueCStr(path)[0] == '\0') {
+        rb_raise(rb_eArgError, "保存先パスを文字列で指定してください。");
+        return Qfalse;
+    }
+
+    recording_path = StringValueCStr(path);
+    recording_fps = NUM2DBL(fps);
+    if (recording_fps <= 0) {
+        rb_raise(rb_eArgError, "FPSは0より大きい値を指定してください。");
+        return Qfalse;
+    }
+
+    if (!camera.isOpened()) {
+        rb_raise(rb_eRuntimeError, "カメラが開かれていません。");
+        return Qfalse;
+    }
+
+    if (camera_width <= 0 || camera_height <= 0) {
+        camera_width = static_cast<int>(camera.get(cv::CAP_PROP_FRAME_WIDTH));
+        camera_height = static_cast<int>(camera.get(cv::CAP_PROP_FRAME_HEIGHT));
+        if ((camera_width <= 0 || camera_height <= 0) && !frame.empty()) {
+            camera_width = frame.cols;
+            camera_height = frame.rows;
+        }
+    }
+
+    if (camera_width <= 0 || camera_height <= 0) {
+        rb_raise(rb_eRuntimeError, "カメラの解像度を取得できませんでした。");
+        return Qfalse;
+    }
+
+    if (video_writer.isOpened()) {
+        video_writer.release();
+    }
+
+    int codec = cv::VideoWriter::fourcc('H', '2', '6', '4');
+    bool opened = video_writer.open(recording_path, codec, recording_fps, cv::Size(camera_width, camera_height), true);
+    if (!opened) {
+        rb_raise(rb_eRuntimeError, "動画ファイルを開けませんでした。");
+        return Qfalse;
+    }
+
+    recording = true;
+    return Qtrue;
+}
+
+static VALUE stop_recording(VALUE self) {
+    if (recording) {
+        video_writer.release();
+        recording = false;
+    }
+    return Qtrue;
+}
+
+static VALUE mat2str(cv::Mat mat) {
+    if (mat.empty()) {
+        return Qnil; // 空のMatオブジェクトはnilを返す
+    }
+    std::vector<uchar> buf;
+    cv::imencode(".jpg", mat, buf);
+    return rb_str_new((const char *)buf.data(), buf.size());
+}
+
+static cv::Mat str2mat(VALUE data) {
+    if (NIL_P(data)) {
+        return cv::Mat();
+    }
+    std::string ruby_str = std::string(RSTRING_PTR(data), RSTRING_LEN(data));
+    std::vector<uchar> cppstr(ruby_str.begin(), ruby_str.end());
+    cv::Mat ret = cv::imdecode(cppstr, cv::IMREAD_COLOR);
+    return ret;
+}
+
+static VALUE write_frame(VALUE self, VALUE image_data) {
+    if (!recording) {
+        rb_raise(rb_eRuntimeError, "録画が開始されていません。");
+        return Qfalse;
+    }
+
+    cv::Mat mat = str2mat(image_data);
+    if (mat.empty()) {
+        rb_raise(rb_eRuntimeError, "フレームデータのデコードに失敗しました。");
+        return Qfalse;
+    }
+
+    if (!video_writer.isOpened()) {
+        rb_raise(rb_eRuntimeError, "動画ファイルが開かれていません。");
+        return Qfalse;
+    }
+
+    if (camera_width > 0 && camera_height > 0 && (mat.cols != camera_width || mat.rows != camera_height)) {
+        cv::resize(mat, mat, cv::Size(camera_width, camera_height));
+    }
+
+    video_writer.write(mat);
+    return Qtrue;
+}
+
+static VALUE take_picture(VALUE self) { // self 引数を追加
+    bool ret = camera.read(frame);
+    if (!ret || frame.empty()) {
+        rb_raise(rb_eRuntimeError, "画像の取得に失敗しました。");
+        return Qfalse;
+    }
+
+    return mat2str(frame);
+}
+
+static VALUE show_movie(VALUE self) {
+    cv::imshow("Camera", frame);
+    return Qtrue;
+}
+
+static VALUE waitKey(int delay) {
+    return cv::waitKey(delay);
+}
+
+static VALUE destroy_window(VALUE self) {
+    cv::destroyAllWindows();
+    return Qtrue;
+}
+
+extern "C" {
+    static VALUE rb_open_mp4(VALUE self, VALUE path) {
+        return open_mp4_source(self, path);
+    }
+
+    static VALUE rb_cam_open(VALUE self, VALUE source, VALUE width, VALUE height) {
+        return open_camera_source(self, source, width, height);
+    }
+
+    static VALUE rb_get(VALUE self) {
+        return take_picture(self); // 引数の数を修正
+    }
+
+    static VALUE rb_start_recording(VALUE self, VALUE path, VALUE fps) {
+        return start_recording(self, path, fps);
+    }
+
+    static VALUE rb_stop_recording(VALUE self) {
+        return stop_recording(self);
+    }
+
+    static VALUE rb_write_frame(VALUE self, VALUE image_data) {
+        return write_frame(self, image_data);
+    }
+
+    static VALUE rb_show_movie(VALUE self) {
+        return show_movie(self);
+    }
+
+    static VALUE rb_wait_key(VALUE self, VALUE delay) {
+        return waitKey(NUM2INT(delay));
+    }
+
+    static VALUE rb_destroy_window(VALUE self) {
+        return destroy_window(self);
+    }
+
+    static VALUE rb_set_frame_pos(VALUE self, VALUE pos) {
+        if (!camera.isOpened()) {
+            rb_raise(rb_eRuntimeError, "カメラまたは動画が開かれていません。");
+            return Qfalse;
+        }
+        int frame_idx = NUM2INT(pos);
+        bool ret = camera.set(cv::CAP_PROP_POS_FRAMES, frame_idx);
+        return ret ? Qtrue : Qfalse;
+    }
+
+    static VALUE rb_get_frame_pos(VALUE self) {
+        if (!camera.isOpened()) {
+            return INT2NUM(-1);
+        }
+        double pos = camera.get(cv::CAP_PROP_POS_FRAMES);
+        return INT2NUM(static_cast<int>(pos));
+    }
+
+    static VALUE rb_get_total_frames(VALUE self) {
+        if (!camera.isOpened()) {
+            return INT2NUM(0);
+        }
+        double count = camera.get(cv::CAP_PROP_FRAME_COUNT);
+        return INT2NUM(static_cast<int>(count));
+    }
+
+    extern void Init_libopencv(void) {
+        VALUE libopencv = rb_define_module("Libopencv");
+        rb_define_singleton_method(libopencv, "cam_open", rb_cam_open, 3);
+        rb_define_singleton_method(libopencv, "open_mp4", rb_open_mp4, 1);
+        rb_define_singleton_method(libopencv, "start_recording", rb_start_recording, 2);
+        rb_define_singleton_method(libopencv, "take_picture", rb_get, 0);
+        rb_define_singleton_method(libopencv, "write_frame", rb_write_frame, 1);
+        rb_define_singleton_method(libopencv, "stop_recording", rb_stop_recording, 0);
+        rb_define_singleton_method(libopencv, "show_movie", rb_show_movie, 0);
+        rb_define_singleton_method(libopencv, "wait_key", rb_wait_key, 1);
+        rb_define_singleton_method(libopencv, "destroy_window", rb_destroy_window, 0);
+        rb_define_singleton_method(libopencv, "set_frame_pos", rb_set_frame_pos, 1);
+        rb_define_singleton_method(libopencv, "get_frame_pos", rb_get_frame_pos, 0);
+        rb_define_singleton_method(libopencv, "get_total_frames", rb_get_total_frames, 0);
+    }
+}
+

data/lib/Lerobot/Dataset/Ruby/reader.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'parquet'
+
+module Lerobot
+  module Dataset
+    module Ruby
+      # LeRobotDatasetWriter が生成した v3 データセットを読むクラス。
+      class Reader
+        attr_reader :root, :info, :tasks
+
+        def initialize(root)
+          @root = File.expand_path(root)
+          @info = load_json('meta/info.json')
+          @tasks = load_tasks
+          @episodes = read_rows(episode_data_path)
+          @frames = read_rows(data_path)
+          validate_dataset
+        end
+
+        def episode_count
+          @episodes.length
+        end
+
+        def frame_count
+          @frames.length
+        end
+
+        def episodes
+          @episodes.map { |episode| episode_metadata(episode) }
+        end
+
+        def episode(index)
+          episode = find_episode(index)
+          from_index = integer_value(episode['dataset_from_index'])
+          to_index = integer_value(episode['dataset_to_index'])
+
+          {
+            episode_index: integer_value(episode['episode_index']),
+            tasks: Array(episode['tasks']),
+            length: integer_value(episode['length']),
+            frames: @frames[from_index...to_index].map { |frame| normalize_frame(frame) }
+          }
+        end
+
+        def each_episode
+          return enum_for(__method__) unless block_given?
+
+          @episodes.each do |episode|
+            yield episode_metadata(episode)
+          end
+        end
+
+        def each_frame(episode_index = nil)
+          return enum_for(__method__, episode_index) unless block_given?
+
+          selected = episode_index.nil? ? @frames : episode(episode_index)[:frames]
+          selected.each { |frame| yield frame }
+        end
+
+        # 指定エピソードを OpenCV ウィンドウで再生する。
+        # ブロックには [フレームメタデータ, JPEG バイト列] を渡す。
+        def play(episode_index, delay: nil)
+          begin
+            require 'libopencv'
+          rescue LoadError
+            require_relative '../../../../ext/opencv/libopencv'
+          end
+
+          episode_data = episode(episode_index)
+          video_path = File.expand_path(video_relative_path, @root)
+          Libopencv.open_mp4(video_path)
+
+          skip_frames(episode_data[:frames].first&.fetch(:frame_index, 0).to_i)
+          frame_delay = delay || (1000.0 / @info.fetch('fps', 30)).round
+
+          episode_data[:frames].each do |metadata|
+            image_bytes = Libopencv.take_picture
+            yield metadata, image_bytes if block_given?
+            Libopencv.show_movie
+            key = Libopencv.wait_key(frame_delay)
+            break if key == 27 || key == 113
+          end
+        ensure
+          Libopencv.destroy_window if defined?(Libopencv)
+        end
+
+        private
+
+        def load_json(relative_path)
+          JSON.parse(File.read(File.join(@root, relative_path)))
+        rescue Errno::ENOENT => error
+          raise ArgumentError, "データセットのファイルが見つかりません: #{error.path}"
+        end
+
+        def load_tasks
+          parquet_path = File.join(@root, 'meta', 'tasks.parquet')
+          raise ArgumentError, "タスク定義が見つかりません: #{parquet_path}" unless File.file?(parquet_path)
+
+          Parquet.each_row(parquet_path).map do |row|
+            { 'task_index' => row['task_index'], 'task' => row['task'] }
+          end
+        end
+
+        def read_rows(relative_path)
+          path = File.join(@root, relative_path)
+          raise ArgumentError, "Parquet ファイルが見つかりません: #{path}" unless File.file?(path)
+
+          Parquet.each_row(path).to_a
+        end
+
+        def data_path
+          @info.dig('data_files', 'data') || 'data/chunk-000/file-000.parquet'
+        end
+
+        def episode_data_path
+          @info['episode_data_files'] || 'meta/episodes/chunk-000/file-000.parquet'
+        end
+
+        def validate_dataset
+          declared_frames = @info['total_frames']
+          declared_episodes = @info['total_episodes']
+          unless declared_frames == @frames.length && declared_episodes == @episodes.length
+            raise ArgumentError, 'info.json と Parquet の件数が一致しません'
+          end
+
+          @episodes.each do |episode|
+            from_index = integer_value(episode['dataset_from_index'])
+            to_index = integer_value(episode['dataset_to_index'])
+            length = integer_value(episode['length'])
+            unless to_index - from_index == length && @frames[from_index...to_index]&.length == length
+              raise ArgumentError, "エピソード #{episode['episode_index']} の範囲が不正です"
+            end
+          end
+        end
+
+        def find_episode(index)
+          episode = @episodes.find { |item| integer_value(item['episode_index']) == index }
+          raise IndexError, "エピソード #{index} が見つかりません" unless episode
+
+          episode
+        end
+
+        def episode_metadata(episode)
+          episode.transform_keys(&:to_sym).merge(
+            episode_index: integer_value(episode['episode_index']),
+            length: integer_value(episode['length'])
+          )
+        end
+
+        def normalize_frame(frame)
+          frame.transform_keys(&:to_sym)
+        end
+
+        def integer_value(value)
+          Integer(value)
+        end
+
+        def video_relative_path
+          @info.dig('data_files', 'videos', 'rgb') ||
+            'videos/rgb/chunk-000/file-000.mp4'
+        end
+
+        def skip_frames(count)
+          count.times { Libopencv.take_picture }
+        end
+      end
+    end
+  end
+end
+
+# 後方互換性のためのエイリアス
+LeRobotDatasetReader = Lerobot::Dataset::Ruby::Reader

data/lib/Lerobot/Dataset/Ruby/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Lerobot
+  module Dataset
+    module Ruby
+      VERSION = "0.1.0"
+    end
+  end
+end