vibes-rb 0.2.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f27d3143c9c22784f9d2b3670d66e905dfd0c923acffe0934cd0c5858865d0c4
+  data.tar.gz: dfb4418bd7415f16ec3b1a4bb702dd9ad113c5fa51babf0ab3adea2efa791617
+SHA512:
+  metadata.gz: 397ab399abc397281cfde397b4e349da431e5b7e99e1faebc8a14faf51f3ba2699133e8291d340351b00e02b08f2fa7c5ed6119f7c412773cac6baac1f715dcf
+  data.tar.gz: b595190c727f6bf3f4a2a715e0affda322984e5dbf75ba8f6e5eedab339b6c68dac7e98ef3c70cd45773c5661d8c198e7ea613f9ae64a36aea8a8c71ed9a281e

data/.yardopts

@@ -0,0 +1,7 @@
+--readme README.md
+--title 'VIBes Documentation'
+--verbose
+--charset utf-8
+--markup markdown
+--default-return self
+'lib/**/*.rb'

data/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README.md

@@ -0,0 +1,43 @@
+
+VIBes
+=====
+
+This gem is a Ruby API to connect to the VIBes viewer (Visualizer for Intervals and Boxes).
+
+You will need the VIBes viewer executable.
+See <https://github.com/ENSTABretagneRobotics/VIBES> to get and install it.
+
+
+Install the vibes-rb gem
+------------------------
+
+~~~bash
+sudo gem install vibes-rb
+~~~
+
+
+Install from sources
+--------------------
+
+~~~bash
+git clone git@gitlab.ensieta.ecole:bollenth/vibes.rb.git
+cd vibes.rb
+gem build vibes-rb.gemspec
+gem install vibes-rb-0.2.3.gem
+~~~
+
+
+Documentation
+-------------
+
+Documentation is available at <https://www.rubydoc.info/gems/vibes-rb>
+
+You can build the documentation using yard:
+
+~~~bash
+gem install yard
+cd vibes.rb
+yard
+firefox doc/index.html
+~~~
+

data/lib/vibes-rb/version.rb

@@ -0,0 +1,3 @@
+module VIBes
+	VERSION = '0.2.3'
+end

data/lib/vibes-rb.rb

@@ -0,0 +1,759 @@
+# Copyright (C) 2020, 2022 Théotime Bollengier <theotime.bollengier@ensta-bretagne.fr>
+#
+# This file is part of vibes.rb
+# 
+# vibes.rb is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# vibes.rb is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public License
+# along with vibes.rb. If not, see <https://www.gnu.org/licenses/>.
+
+
+require 'json'
+require_relative 'vibes-rb/version.rb'
+
+
+# The {VIBes} module handles communication with the [VIBes viewer](https://github.com/ENSTABretagneRobotics/VIBES) executable.
+module VIBes
+	# File used to communicate with the viewer in the JSON format
+	# @return [File, nil]
+	# @!visibility private
+	@@vibes_channel = nil 
+
+
+	# Open communication with the VIBes viewer.
+	# If the viewer is not executing, forks to launch it in a new process.
+	#
+	# Normaly the user do not have to call this function,
+	# it is automatically called when the first message is being sent 
+	# to the viewer.
+	#
+	# It is only useful when the user wants to save the commands in a
+	# specific file instead of sending them to the viewer.
+	# In this case, this method should be called before any figure method is called.
+	# @example
+	#  VIBes.begin_drawing('titi.json')
+	#  f = VIBes::Figure.new
+	#  f.width = 500
+	#  f.height = 250
+	#  f.draw_box([-2, 3], [-1, 4], color: 'k[r]')
+	#  VIBes.end_drawing
+	#  puts File.read('titi.json')
+	#  # {"action":"new","figure":"default"}
+	#  # {"action":"set","figure":"default","properties":{"width":500}}
+	#  # {"action":"set","figure":"default","properties":{"height":500}}
+	#  # {"action":"draw","figure":"default","shape":{"format":"k[r]","type":"box","bounds":[-2.0,3.0,-1.0,4.0]}}
+	# @param fname [String, nil] name of the file used to exchange data with the viewer
+	def self.begin_drawing(fname = nil)
+		if fname.kind_of?(String) and not(fname.empty?) then
+			@@vibes_channel.close if @@vibes_channel
+			@@vibes_channel = File.open(fname, 'a')
+		else
+			user_dir = ENV['USERPROFILE'] # windows
+			user_dir = ENV['HOME'] if user_dir.nil?
+			if user_dir then # Environment variable found, connect to a file in user's profile directory
+				fname = File.join(user_dir, '.vibes.json')
+				unless File.exist?(fname) then
+					Process.detach(fork{Process.exec('VIBes-viewer')})
+					startTime = Time.now
+					until File.exist?(fname) do
+						sleep 0.1
+						if (Time.now - startTime) > 1 then
+							warn 'VIBes-viewer process does not seem to be started'
+							break
+						end
+					end
+				end
+				begin_drawing(fname)
+			else # Connect to a file in working directory
+				begin_drawing('vibes.json')
+			end
+		end
+		self
+	end
+
+
+	# Close the communication channel with the viewer.
+	#
+	# In most cases, users don't have to call this method.
+	# It is only useful when commands are saved in a specific file
+	# instead of being send to the VIBes viewer.
+	# @see begin_drawing
+	def self.end_drawing
+		if @@vibes_channel then
+			@@vibes_channel.close
+			@@vibes_channel = nil
+		end
+		self
+	end
+
+
+	# Send a message to the viewer.
+	# Initiate the viewer via {begin_drawing}
+	# if the communication channel is not yet opened.
+	# @!visibility private
+	def self.msg(str)
+		begin_drawing unless @@vibes_channel
+		@@vibes_channel.write str
+		@@vibes_channel.flush
+		self
+	end
+
+
+	# {Figure} is the class used to handle a single figure with the viewer.
+	class Figure
+		# Name of the figure that will appear on the viewer.
+		# If two instances of {Figure} have the same name,
+		# they will treat the same figure on the viewer.
+		# @return [String] the figure name
+		attr_reader :name
+
+
+		# @!group Figure management
+
+
+		# Create a new figure name _figname_.
+		# @example
+		#  f = VIBes::Figure.new 'Name of the figure'
+		# @param figure_name [String] the name of the figure
+		# @return [Figure]
+		def initialize(figure_name = 'default')
+			figure_name = 'default' if not(figure_name.is_a?(String)) or figure_name.empty?
+			@name = figure_name
+			VIBes.msg "{\"action\":\"new\",\"figure\":\"#{@name}\"}\n\n"
+		end
+
+
+		# Close the figure
+		def close
+			VIBes.msg "{\"action\":\"close\",\"figure\":\"#{@name}\"}\n\n"
+			self
+		end
+
+
+		# Clear the content of the figure
+		def clear
+			VIBes.msg "{\"action\":\"clear\",\"figure\":\"#{@name}\"}\n\n"
+			self
+		end
+
+
+		# Save the figure on disk.
+		# Available formats are: png, jpeg, bmp and svg.
+		# @param file_name [String] path of the file to save the figure into.
+		def save_image(file_name = nil, **kwargs)
+			file_name = '' unless file_name.is_a?(String) and file_name.length > 0
+			kwargs[:action] = :export
+			kwargs[:figure] = @name
+			kwargs[:file] = File.expand_path(file_name)
+			VIBes.msg "#{kwargs.to_json}\n\n"
+			self
+		end
+
+
+		# Set figure properties using keyword arguments.
+		# @example
+		#  # Set a new position and viewport
+		#  fig.set_properties(x: 100, y: 50, width: 500, height: 250)
+		# @see []=
+		# @see method_missing
+		def set_properties(**kwargs)
+			VIBes.msg "{\"action\":\"set\",\"figure\":\"#{@name}\",\"properties\":#{kwargs.to_json}}\n\n"
+			self
+		end
+
+
+		# Set a property using the form [property]=value
+		# @example
+		#  # Set the new x position
+		#  fig[:x] = 100
+		# @see set_properties
+		# @see method_missing
+		def []=(key, value)
+			set_properties(**{key.to_sym => value})
+		end
+
+
+		# Set a property using the form `self.property=value`.
+		# If the method is not known to the figure and is in the form 'figure.method=val',
+		# call the {set_properties} method whith the method name as key _val_ as value.
+		# @example
+		#  f = VIBes::Figure.new
+		#  f.width = 500
+		#  f.height = 250
+		#  # width= and height= are not instance methods of Figure,
+		#  # so the last two method calls are translated into
+		#  # f.set_properties(width: 500)
+		#  # f.set_properties(height: 250)
+		# @see set_properties
+		# @see []=
+		def method_missing(m, *args, &block)
+			if m.to_s =~ /=$/ then
+				raise 'not expecting a block' if block
+				raise 'expecting 1 and only 1 argument' if args.length != 1
+				self[m.to_s.sub(/=$/, '')] = args.first
+			else
+				super
+			end
+			self
+		end
+
+
+		# Set the size of the figure
+		# @param width [Integer]
+		# @param height [Integer]
+		def set_size(width, height)
+			set_properties(width: width.to_i, height: height.to_i)
+		end
+
+
+		# Set the position of the figure window on the screen
+		# @param x [Float] horizontal axis position
+		# @param y [Float] vertical axis position
+		def set_pos(x, y)
+			set_properties(x: x.to_i, y: y.to_i)
+		end
+
+
+		# @!group Axis management
+
+
+		# Set axes limits to the bounding box of the drawing.
+		# @see axis_equal
+		def axis_auto
+			set_properties(viewbox: :auto)
+		end
+
+
+		# Same as {#axis_auto} but with the same ratio on the two axis.
+		# @see axis_auto
+		def axis_equal
+			set_properties(viewbox: :equal)
+		end
+
+
+		# Set the rectangle to be displayed.
+		# @overload axis_limits(x_min, x_max, y_min, y_max)
+		#  @param [Float, Integer]
+		# @overload axis_limits(x_range, y_range)
+		#  @param [Range<Float, Integer>]
+		# @overload axis_limits(x_interval, y_interval)
+		#  @param [Interval] an object that respond to _lower_bound_ and _upper_bound_
+		# @overload axis_limits(xy_box)
+		#  @param [IntervalVector] an interval vector of 2 intervals
+		def axis_limits(*v)
+			a = []
+			v.each do |e|
+				case e
+				when Numeric
+					a << e.to_f
+				when Range
+					l = e.begin.to_f
+					u = e.end.to_f
+					l, u = [u, l] if l > u
+					a << l
+					a << u
+				when Array
+					raise "array must have 1 or 2 elements" if e.length < 1 or e.length > 2
+					l = e.first.to_f
+					u = e.last.to_f
+					l, u = [u, l] if l > u
+					a << l
+					a << u
+				else
+					if VIBes::object_is_an_interval?(e)
+						a << e.lower_bound
+						a << e.upper_bound
+					elsif VIBes::object_is_a_box?(e)
+						raise "the box is expected to have 2 dimensions, not #{e.length}" if e.length != 2
+						a << e[0].lower_bound
+						a << e[0].upper_bound
+						a << e[1].lower_bound
+						a << e[1].upper_bound
+					else
+						raise "expecting floats, ranges, 2 element arrays, intervals or box, not #{e.class}"
+					end
+				end
+			end
+			raise "Should have 4 coordinates, not #{a.length}" if a.length != 4
+			set_properties(viewbox: a)
+		end
+
+
+		# Set axis labels
+		# @overload axis_labels(x_label, y_label)
+		#  @param [String]
+		def axis_labels(*labels)
+			set_properties(axislabels: labels.collect!{|o| o.to_s})
+		end
+			
+
+		# @!group Groups
+
+
+		# Create a new group with the specified group name and parameters.
+		#
+		# Groups can be created to gather objects which share common properties (color, ...).
+		# Then objects can be added to groups by using the _group:_ keyword.
+		# @param group_name [String] name of the group
+		# @param kwargs optional keyword arguments
+		# @example
+		#  f = VIBes::Figure.new 'test groups'
+		#  f.new_group('my group', format: 'r[darkBlue]')
+		#  f.draw_circle([0, 0], 3, group: 'my group')
+		#  f.draw_box(3..6, 0..3, group: 'my group')
+	 	def new_group(group_name, **kwargs)
+			kwargs = {type: :group, name: group_name.to_s}
+			kwargs.each{|k, v| kwargs[k.to_sym] = v}
+			draw kwargs
+		end
+
+
+		# Clear the content of the group _group_name_ from the figure.
+		# @param group_name [String] name of the group to remove
+		# @param kwargs optional keyword arguments
+		def clear_group(group_name, **kwargs)
+     		kwargs[:action] = :clear
+     		kwargs[:figure] = @name
+			kwargs[:group] = group_name.to_s
+			VIBes.msg "#{kwargs.to_json}\n\n"
+			self
+		end
+
+
+		# @!group Drawing functions
+
+
+		# Draw a box
+		# @param a [Numeric, Range, Array, Interval, IntervalVector] bounds of the box
+		# @param color [String] color format
+		# @param kwargs optional keyword arguments
+		# @example Draw a box with 𝒙 ∈ [0, 1] and 𝒚 ∈ [2, 3]
+		#  f = VIBes::Figure.new
+		#  # Using 4 numeric bounds
+		#  f.draw_box(0, 1, 2, 3, color: 'k[r]')
+		#  # Using 2 ranges
+		#  f.draw_box(0..1, 2..3, color: 'k[b]')
+		#  # Using 2 arrays
+		#  f.draw_box([0, 1], [2, 3], color: 'k[g]')
+		#  # Using 2 intervals
+		#  x = P1788::Interval[0, 1]
+		#  y = P1788::Interval[2, 3]
+		#  f.draw_box(x, y, color: 'k[y]')
+		#  # Using an interval vector
+		#  b = P1788::IntervalVector[x, y]
+		#  f.draw_box(b, color: 'k[c]')
+		def draw_box(*a, color: nil, **kwargs)
+			c = []
+			f = nil
+			a.each do |e|
+				case e
+				when Numeric
+					c << e.to_f
+				when Range
+					l = e.begin.to_f
+					u = e.end.to_f
+					l, u = [u, l] if l > u
+					c << l
+					c << u
+				when Array
+					raise "array must have 1 or 2 elements" if e.length < 1 or e.length > 2
+					l = e.first.to_f
+					u = e.last.to_f
+					l, u = [u, l] if l > u
+					c << l
+					c << u
+				when String
+					f = e
+				else
+					if VIBes::object_is_an_interval?(e) then
+						c << e.lower_bound
+						c << e.upper_bound
+					elsif VIBes::object_is_a_box?(e) then
+						e.each do |v|
+							c << v.lower_bound
+							c << v.upper_bound
+						end
+					else
+						raise "expecting floats, ranges, 2 element arrays, intervals or boxes, not #{e.class}"
+					end
+				end
+			end
+			raise "Should have a multiple of 2 coordinates, not #{c.length}" if c.length % 2 != 0
+			kwargs[:format] = f if f
+			kwargs[:format] = color if color.is_a?(String)
+			kwargs[:type] = :box
+			kwargs[:bounds] = c
+			draw(kwargs)
+		end
+
+
+		# Draw multiple boxes at once
+		# @param boxes [IntervalVector, Array<IntervalVector>] Boxes or an array of boxes
+		def draw_boxes(*boxes, color: nil, **kwargs)
+			kwargs[:bounds] = []
+			boxes.flatten!
+			color = boxes.select{|v| v.is_a?(String)}.first if color.nil?
+			boxes.reject!{|v| v.is_a?(String)}
+			boxes.each do |b|
+				if VIBes::object_is_a_box?(b) then
+					ba = []
+					b.each do |v|
+						ba << v.lower_bound
+						ba << v.upper_bound
+					end
+					kwargs[:bounds] << ba
+				else
+					raise "expecting interval vectors, not #{b.class}"
+				end
+			end
+			kwargs[:type] = 'boxes'
+			kwargs[:format] = color if color.is_a?(String)
+			draw(kwargs)
+		end
+
+
+		# Draw the union of multiple boxes.
+		# @param boxes [IntervalVector, Array<IntervalVector>] Boxes or an array of boxes
+		def draw_boxes_union(*boxes, color: nil, **kwargs)
+			kwargs[:bounds] = []
+			boxes.flatten!
+			color = boxes.select{|v| v.is_a?(String)}.first if color.nil?
+			boxes.reject!{|v| v.is_a?(String)}
+			boxes.each do |b|
+				if VIBes::object_is_a_box?(b) then
+					ba = []
+					b.each do |v|
+						ba << v.lower_bound
+						ba << v.upper_bound
+					end
+					kwargs[:bounds] << ba
+				else
+					raise "expecting interval vectors, not #{b.class}"
+				end
+			end
+			kwargs[:type] = 'boxes union'
+			kwargs[:format] = color if color.is_a?(String)
+			draw(kwargs)
+		end
+
+
+		# Draw a point.
+		# @overload draw_point(cx, cy, radius: 2, color: 'k', **kwargs)
+		#  @param cx [Float] point _x_ position
+		#  @param cy [Float] point _y_ position
+		#  @param radius [Float] point display radius in pixel
+		def draw_point(*a, radius: 2, color: nil, **kwargs)
+			kwargs[:type] = :point
+			kwargs[:point] = a.flatten.collect(&:to_f)
+			kwargs[:Radius] = radius.to_f if radius
+			kwargs[:format] = color if color.is_a?(String)
+			draw(kwargs)
+		end
+
+
+		# Draw multiple points at once
+		# @example
+		#  # Draw three points
+		#  f.draw_points([-1, -1], [0, 1], [1, -1])
+		# @see draw_point
+		def draw_points(*a, radius: 2, color: nil, **kwargs)
+			el = nil
+			a.each do |e|
+				raise "expecting arrays of the same size" unless e.is_a?(Array) and (el.nil? or e.length == el)
+				el = e.length
+			end
+			kwargs[:type] = :points
+			kwargs[:centers] = a.collect{|e| e.collect(&:to_f)}
+			kwargs[:Radius] = radius.to_f if radius
+			kwargs[:format] = color if color.is_a?(String)
+			draw(kwargs)
+		end
+
+
+		# Draw a line between two points
+		# @overload draw_line(a_start, a_end, color: 'r', **kwargs)
+		#  @param [Array<Float>] point coordinates in arrays
+		# @overload draw_line(p1: a_start, p2: a_end, color: 'k', **kwargs)
+		#  @param [Array<Float>] point coordinates in arrays
+		# @example
+		#  draw_line([0, 0], [1, 1])
+		#  draw_line(p1: [0, 0], p2: [1, 1])
+		def draw_line(ps=nil, pe=nil, p1: [0, 0], p2: [1, 1], color: nil, **kwargs)
+			kwargs[:type] = :line
+			p1 = ps if ps.is_a?(Array)
+			p2 = pe if pe.is_a?(Array)
+			raise 'The start and end points must have the same number of coordinates' if p1.length != p2.length
+			kwargs[:points] = [p1.collect(&:to_f), p2.collect(&:to_f)]
+			kwargs[:format] = color if color.is_a?(String)
+			draw(kwargs)
+		end
+
+
+		# Draw an arrow
+		# @example
+		#  # Draw an array from (0,0) to (1,1), with a tip length of 0.2
+		#  f.draw_arrow([0, 0], [1, 1], 0.2, color: 'r[r]')
+		#  f.draw_arrow(p1: [0, 0], p2: [1, 1], tip_length: 0.2, color: 'k[k]')
+		def draw_arrow(ps=nil, pe=nil, tl=nil, p1: [0, 0], p2: [1, 1], tip_length: nil, color: nil, **kwargs)
+			kwargs[:type] = :arrow
+			p1 = ps if ps.is_a?(Array)
+			p2 = pe if pe.is_a?(Array)
+			raise 'The start and end points must have the same number of coordinates' if p1.length != p2.length
+			kwargs[:points] = [p1.collect(&:to_f), p2.collect(&:to_f)]
+			kwargs[:format] = color if color.is_a?(String)
+			if tl != nil then
+				kwargs[:tip_length] = tl.to_f 
+			elsif tip_length.kind_of?(Numeric) then
+				kwargs[:tip_length] = tip_length.to_f 
+			elsif p1.length == 2 and p2.length == 2 then
+				kwargs[:tip_length] = Math.sqrt((p2.first - p1.first)**2 + (p2.last - p1.last)**2)/10.0
+			else
+				kwargs[:tip_length] = 0.1
+			end
+			draw(kwargs)
+		end
+
+
+		# Draw a circle.
+		# @example
+		#  # Draw a circle of center (-1,0) and radius 0.5
+		#  f.draw_circle([-1, 0], 0.5)
+		def draw_circle(c, r, color: nil, **kwargs)
+			draw_ellipse(c, [r, r], color: color, **kwargs)
+		end
+
+
+		# Draw a Ring.
+		# @example
+		#  # Draw a ring of center (-1,0), min radius: 0.5 and max radius: 1
+		#  f.draw_ring([-1, 0], [0.5, 1], color: 'r[g]')
+		#  f.draw_ring(center: [-1, 0], radius: [0.5, 1], color: 'r[g]')
+		def draw_ring(cent=nil, rad=nil, center: [0, 0], radius: [1, 2], color: nil, **kwargs)
+			kwargs[:type] = :ring
+			kwargs[:center] = (cent.is_a?(Array) ? cent : center).collect(&:to_f)
+			kwargs[:rho] = (rad.is_a?(Array) ? rad : radius).collect(&:to_f)
+			kwargs[:format] = color if color.is_a?(String)
+			draw(kwargs)
+		end
+
+
+		# Draw a polygon
+		# @example
+		#  f.draw_polygon([-1, -1], [0, 1], [1, -1])
+		def draw_polygon(*a, color: nil, **kwargs)
+			el = nil
+			a.each do |e|
+				raise "expecting arrays of the same size" unless e.is_a?(Array) and (e.length == el or el.nil?)
+				el = e.length
+			end
+			kwargs[:type] = :polygon
+			kwargs[:bounds] = a.collect{|e| e.collect(&:to_f)}
+			kwargs[:format] = color if color.is_a?(String)
+			draw(kwargs)
+		end
+
+
+		# Draw an image.
+		# @param fname [String] file name of the image to draw
+		# @param pos [Array<Float>] (x,y) position of the upper left corner of the image on the figure
+		# @param resolution [Array<Float>] horizontal and vertical resolution to display the image. If the vertical resolution is positive, the image may be displayed upside-down.
+		# @example
+		#  # Display lena.png (512x512 pixels) so tha it fills the box (0,1)x(0,1)
+		#  f.draw_raster('lena.png', pos: [0, 1], resolution: [1.0/512, -1.0/512])
+		#  f.draw_raster('lena.png', [0, 1], [1.0/512, -1.0/512])
+		def draw_raster(fname, po=nil, re=nil, pos: [0, 0], resolution: [1, -1], **kwargs)
+			kwargs[:type] = :raster
+			kwargs[:filename] = fname.to_s
+			kwargs[:ul_corner] = (po.is_a?(Array) ? po : pos).collect(&:to_f)
+			kwargs[:scale] = (re.is_a?(Array) ? re : resolution).collect(&:to_f)
+			draw(kwargs)
+		end
+
+
+		# Draw a pie
+		# @param center [Array<Float>]
+		# @param radius [Array<Float>] minimal and maximal radius
+		# @param theta  [Array<Float>] minimal and maximal angle, in radians or degrees depending on _use_radians_
+		# @param use_radians [Boolean] use radians or degrees
+		# @example
+		#  f.draw_pie(center: [0, 0], radius: [1, 2], theta: [0, 45], use_radians: false)
+		#  f.draw_pie([0, 0], [1, 2], [0, 45], color: '[r]')
+		def draw_pie(cent=nil, rad=nil, thet=nil, center: [0, 0], radius: [1, 2], theta: [0, 45], use_radians: false, color: nil, **kwargs)
+			kwargs[:type] = :pie
+			kwargs[:center] = (cent.is_a?(Array) ? cent : center).collect(&:to_f)
+			kwargs[:rho] = (rad.is_a?(Array) ? rad : radius).collect(&:to_f)
+			kwargs[:theta] = (thet.is_a?(Array) ? thet : theta).collect(&:to_f)
+			kwargs[:theta].collect!{|v| v*180/Math::PI} if use_radians
+			kwargs[:format] = color if color.is_a?(String)
+			draw(kwargs)
+		end
+
+
+		# Draw text on the figure
+		# @note Does not seem to work on Linux
+		def draw_text(str=nil, po=nil, s=nil, text: '', pos: [0, 0], scale: 1, color: nil, **kwargs)
+			kwargs[:type] = :text
+			kwargs[:text] = (str.nil? ? text : str).to_s
+			kwargs[:position] = (po.is_a?(Array) ? po : pos).collect(&:to_f)
+			kwargs[:scale] = (s.nil? ? scale : s).to_f
+			kwargs[:format] = color if color.is_a?(String)
+			draw(kwargs)
+		end
+
+
+		# Draw an AUV (yellow submarine) centered at _center_, with heading _heading_ degrees and size _length_.
+		# @param center [Array<Float>] Center of the AUV
+		# @param heading [Float] heading of the AUV in degree
+		# @param length [Float] size of the AUV
+		# @example
+		#  f.draw_AUV(center: [0, -1], heading: 45, length: 1.0, color: 'k[y]')
+		#  f.draw_AUV([0, -1], 45, 1.0, color: 'k[y]')
+		def draw_AUV(cent=nil, rt=nil, len=nil, center: [0, 0], heading: 0.0, length: 1.0, color: nil, **kwargs)
+			kwargs[:type] = :vehicle_auv
+			kwargs[:center] = (cent.is_a?(Array) ? cent : center).collect(&:to_f)
+			kwargs[:orientation] = (rt.nil? ? heading : rt).to_f
+			kwargs[:length] = Math.sqrt((len.nil? ? length : len).to_f)
+			kwargs[:format] = color if color.is_a?(String)
+			draw(kwargs)
+		end
+
+
+		# Draw a vehicle centered at _center_, with heading _heading_ degrees and of size _length_.
+		# @example
+		#  f.draw_vehicle(center: [0, -1], heading: 45, length: 1.0, color: 'k[y]')
+		#  f.draw_vehicle([0, -1], 45, 1.0, color: 'k[y]')
+		def draw_vehicle(cent=nil, rt=nil, len=nil, center: [0, 0], heading: 0.0, length: 1.0, color: nil, **kwargs)
+			kwargs[:type] = :vehicle
+			kwargs[:center] = (cent.is_a?(Array) ? cent : center).collect(&:to_f)
+			kwargs[:orientation] = (rt.nil? ? heading : rt).to_f
+			kwargs[:length] = Math.sqrt((len.nil? ? length : len).to_f)
+			kwargs[:format] = color if color.is_a?(String)
+			draw(kwargs)
+		end
+
+
+		# Draw a tank centered at _center_, with heading _heading_ degrees and of size _length_.
+		# @example
+		#  f.draw_tank(center: [0, -1], heading: 45, length: 1.0, color: 'k[g]')
+		#  f.draw_tank([0, -1], 45, 1.0, color: 'k[g]')
+		def draw_tank(cent=nil, rt=nil, len=nil, center: [0, 0], heading: 0.0, length: 1.0, color: nil, **kwargs)
+			kwargs[:type] = :vehicle_tank
+			kwargs[:center] = (cent.is_a?(Array) ? cent : center).collect(&:to_f)
+			kwargs[:orientation] = (rt.nil? ? heading : rt).to_f
+			kwargs[:length] = (len.nil? ? length : len).to_f
+			kwargs[:format] = color if color.is_a?(String)
+			draw(kwargs)
+		end
+
+
+		# Draw an ellipse centered at (cx,cy) with semi-major and minor axes _a_ and _b_, and rotated by _rot_ degrees.
+		def draw_ellipse(cent=nil, ax=nil, rt=nil, center: nil, cx: 0.0, cy: 0.0, axis: nil, a: 1.0, b: a, rot: 0.0, color: nil, **kwargs)
+			kwargs = {} if kwargs.nil?
+			kwargs[:type] = :ellipse
+			if cent.is_a?(Array) then
+				kwargs[:center] = cent.collect(&:to_f)
+			else
+				kwargs[:center] = center.is_a?(Array) ? center.collect(&:to_f) : [cx.to_f, cy.to_f]
+			end
+			if ax.is_a?(Array) then
+				kwargs[:axis] = ax.collect(&:to_f)
+			else
+				kwargs[:axis] = axis.is_a?(Array) ? axis.collect(&:to_f) : [a.to_f, b.to_f]
+			end
+			kwargs[:orientation] = rt.nil? ? rot.to_f : rt.to_f
+			kwargs[:format] = color if color.is_a?(String)
+			draw(kwargs)
+		end
+
+
+		def draw_confidence_ellipse(cent=nil, cov=nil, sig=nil, center: nil, cx: 0.0, cy: 0.0, covariance: nil, sxx: 1.0, sxy: 1.0, syy: 1.0, sigma: 1.0, color: nil, **kwargs)
+			kwargs = {} if kwargs.nil?
+			kwargs[:type] = :ellipse
+			if cent.is_a?(Array) then
+				kwargs[:center] = cent.collect(&:to_f)
+			else
+				kwargs[:center] = center.is_a?(Array) ? center.collect(&:to_f) : [cx.to_f, cy.to_f]
+			end
+			if cov.is_a?(Array) then
+				kwargs[:covariance] = cov.collect(&:to_f)
+			else
+				kwargs[:covariance] = covariance.is_a?(Array) ? covariance.collect(&:to_f) : [sxx.to_f, sxy.to_f, sxy.to_f, syy.to_f]
+			end
+			kwargs[:sigma] = sig.nil? ? sigma.to_f : sig.to_f
+			kwargs[:format] = color if color.is_a?(String)
+			draw(kwargs)
+		end
+
+
+		# @!endgroup
+
+
+		def remove_object(object_name, **kwargs)
+     		kwargs[:action] = :delete
+     		kwargs[:figure] = @name
+	 		kwargs[:object] = object_name.to_s
+			VIBes.msg "#{kwargs.to_json}\n\n"
+			self
+		end
+
+
+		def set_object_properties(object_name, **kwargs)
+			h = {action: :set, figure: @name, object: object_name.to_s, properties: kwargs.to_json}
+			VIBes.msg "#{h.to_json}\n\n"
+			self
+		end
+
+
+		private
+
+
+		def draw(kwargs)
+			VIBes.msg "{\"action\":\"draw\",\"figure\":\"#{@name}\",\"shape\":#{kwargs.to_json}}\n\n"
+			self
+		end
+	end
+
+
+	# Check if an object is an interval vector,
+	# using @@interval_vector_class_cache
+	# @!visibility private
+	def self.object_is_a_box?(obj)
+		return true if @@interval_vector_class_cache[obj.class] == true
+		if obj.respond_to?(:is_an_interval_vector?) and obj.is_an_interval_vector? == true then
+			@@interval_vector_class_cache[obj.class] = true
+			return true
+		end
+		return false
+	end
+
+
+	# Check if an object is an interval,
+	# using @@interval_class_cache
+	# @!visibility private
+	def self.object_is_an_interval?(obj)
+		return true if @@interval_class_cache[obj.class] == true
+		if obj.respond_to?(:is_an_interval?) and obj.is_an_interval? == true then
+			@@interval_class_cache[obj.class] = true
+			return true
+		end
+		return false
+	end
+
+
+	# @see object_is_a_box?
+	# @!visibility private
+	@@interval_vector_class_cache = {}
+
+	# @see object_is_an_interval?
+	# @!visibility private
+	@@interval_class_cache = {}
+end
+

data/samples/animation.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require '../lib/vibes-rb.rb'
+
+f = VIBes::Figure.new
+f.width = 512
+f.height = 512
+f.axis_limits(-1.2 .. 1.2, -1.2 .. 1.2)
+
+t = 0.0
+loop do
+	x = Math.cos(t)
+	y = Math.sin(2*t)
+	dx = -Math.sin(t)
+	dy = 2*Math.cos(2*t)
+	a = 180*Math.atan2(dy, dx)/Math::PI
+	t += 0.01
+	f.draw_point(x, y)
+	f.remove_object('car')
+	f.draw_vehicle([x, y], a, 0.2, color: 'k[y]', name: 'car')
+	break if t >= 2*Math::PI
+	t -= 2*Math::PI if t >= 2*Math::PI
+	sleep(0.02)
+end
+

data/samples/example_allfigures.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require 'vibes-rb'
+
+f = VIBes::Figure.new 'all figures'
+
+f.x = 100
+f.y = 100
+f.width = 500
+f.height = 500
+
+f.draw_arrow([-1, -1], [1, 1], 0.6, color: 'k[k]')
+f.draw_AUV([4, 0], 45, 2, color: 'k[y]')
+f.draw_box([7, 9], [-2, 2], color: '[b]')
+f.draw_tank([12, 0], 45, 3, color: 'k[r]')
+f.draw_box([7, 9], [-2, 2], color: '[b]')
+f.draw_circle([0, -4], 1, color: 'g[m]')
+f.draw_ellipse([4, -4], [2,1], 45, color: 'r[darkCyan]')
+f.draw_line([7, -5], [9, -3], color: 'k')
+f.draw_pie([10, -6], [1, 2.5], [20,70], color: 'y[cyan]')
+f.draw_polygon([-1, -9], [1, -9], [0, -7], color: 'k[orange]')
+f.draw_ring([4, -8], [1, 2], color: '[red]')
+f.draw_vehicle([8, -8], 20, 1, color: '[darkBlue]')
+f.draw_point(12, -8, radius: 2, color: '[k]')
+
+f.axis_equal
+

data/vibes-rb.gemspec

@@ -0,0 +1,25 @@
+require File.expand_path('../lib/vibes-rb/version.rb', __FILE__)
+
+Gem::Specification.new do |s|
+	s.name = 'vibes-rb'
+	s.version = VIBes::VERSION
+	s.date = Time.now.strftime '%Y-%m-%d'
+	s.summary = "Ruby API to connect to VIBes-viewer (Visualizer for Intervals and Boxes)."
+	s.description = "The vibes-rb gem allows to connect to the VIBes viewer (Visualizer for Intervals and Boxes). See https://github.com/ENSTABretagneRobotics/VIBES"
+	s.license = 'LGPL-3.0'
+	s.authors = ["Théotime Bollengier"]
+	s.email = 'theotime.bollengier@ensta-bretagne.fr'
+	s.homepage = 'https://gitlab.ensta-bretagne.fr/bollenth/vibes.rb'
+	s.add_runtime_dependency 'json', '~> 2.3', '>= 2.3.0'
+	s.files = [
+		'LICENSE',
+		'README.md',
+		'vibes-rb.gemspec',
+		'.yardopts',
+		'lib/vibes-rb.rb',
+		'lib/vibes-rb/version.rb',
+		'samples/example_allfigures.rb',
+		'samples/animation.rb'
+	]
+end
+

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: vibes-rb
+version: !ruby/object:Gem::Version
+  version: 0.2.3
+platform: ruby
+authors:
+- Théotime Bollengier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-01-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+description: The vibes-rb gem allows to connect to the VIBes viewer (Visualizer for
+  Intervals and Boxes). See https://github.com/ENSTABretagneRobotics/VIBES
+email: theotime.bollengier@ensta-bretagne.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- LICENSE
+- README.md
+- lib/vibes-rb.rb
+- lib/vibes-rb/version.rb
+- samples/animation.rb
+- samples/example_allfigures.rb
+- vibes-rb.gemspec
+homepage: https://gitlab.ensta-bretagne.fr/bollenth/vibes.rb
+licenses:
+- LGPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key: 
+specification_version: 4
+summary: Ruby API to connect to VIBes-viewer (Visualizer for Intervals and Boxes).
+test_files: []