ruby-gr 0.0.2 → 0.0.3

data/lib/gr/ffi.rb

@@ -8,7 +8,7 @@ module GR
 
     begin
       ffi_lib GR.ffi_lib
-    rescue LoadError => e
+    rescue LoadError
       raise LoadError, 'Could not find GR Framework'
     end
 
@@ -47,7 +47,7 @@ module GR
     attach_function :gr_setmarkertype, %i[int], :void
     attach_function :gr_inqmarkertype, %i[pointer], :void
     attach_function :gr_setmarkersize, %i[double], :void
-    # gr_inqmarkersize is not implemented.
+    attach_function :gr_inqmarkersize, %i[pointer], :void
     attach_function :gr_setmarkercolorind, %i[int], :void
     attach_function :gr_inqmarkercolorind, %i[pointer], :void
     attach_function :gr_settextfontprec, %i[int int], :void
@@ -126,16 +126,16 @@ module GR
     attach_function :gr_setarrowstyle, %i[int], :void
     attach_function :gr_setarrowsize, %i[double], :void
     attach_function :gr_drawarrow, %i[double double double double], :void
-    # attach_function :gr_readimage, %i[pointer pointer pointer pointer], :int
+    attach_function :gr_readimage, %i[string pointer pointer pointer], :int
     attach_function :gr_drawimage, %i[double double double double int int pointer int], :void
-    # attach_function :gr_importgraphics, %i[string], :int
+    attach_function :gr_importgraphics, %i[string], :int
     attach_function :gr_setshadow, %i[double double double], :void
     attach_function :gr_settransparency, %i[double], :void
     attach_function :gr_setcoordxform, %i[pointer], :void
     attach_function :gr_begingraphics, %i[string], :void
     attach_function :gr_endgraphics, %i[], :void
-    # attach_function :gr_getgraphics
-    # attach_function :gr_drawgraphics
+    attach_function :gr_getgraphics, %i[], :string
+    attach_function :gr_drawgraphics, %i[string], :int
     attach_function :gr_mathtex, %i[double double string], :void
     attach_function :gr_inqmathtex, %i[double double string pointer pointer], :void
     attach_function :gr_beginselection, %i[int int], :void
@@ -151,14 +151,14 @@ module GR
     attach_function :gr_selectcontext, %i[int], :void
     attach_function :gr_destroycontext, %i[int], :void
     attach_function :gr_uselinespec, %i[string], :void
-    # attach_function :gr_delaunay
+    # attach_function :gr_delaunay, %i[int pointer pointer pointer pointer], :void
     attach_function :gr_reducepoints, %i[int pointer pointer int pointer pointer], :void
     attach_function :gr_trisurface, %i[int pointer pointer pointer], :void
     attach_function :gr_gradient, %i[int int pointer pointer pointer pointer pointer], :void
     attach_function :gr_quiver, %i[int int pointer pointer pointer pointer int], :void
-    # attach_function :gr_interp2
+    attach_function :gr_interp2, %i[int int pointer pointer pointer int int pointer pointer pointer int double], :void
 
-    # gr_newmeta
+    # attach_function :gr_newmeta
     # attach_function :gr_deletemeta
     # attach_function :gr_finalizemeta
     # attach_function :gr_meta_args_push
@@ -185,6 +185,7 @@ module GR
     # attach_function :gr_meta_max_plotid
     # attach_function :gr_dumpmeta
     # attach_function :gr_dumpmeta_json
+
     attach_function :gr_version, %i[], :pointer
     attach_function :gr_shadepoints, %i[int pointer pointer int int int], :void
     attach_function :gr_shadelines, %i[int pointer pointer int int int], :void

data/lib/gr/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module GR
+  VERSION = GRCommons::VERSION
+end

data/lib/gr3.rb

@@ -25,6 +25,7 @@ module GR3
              end
 
   require_relative 'gr_commons'
+  require_relative 'gr3/version'
   require_relative 'gr3/ffi'
   require_relative 'gr3/gr3base'
 
@@ -50,50 +51,455 @@ module GR3
   extend CheckError
 
   class << self
+    # This method initializes the gr3 context.
+    def gr3_init(*)
+      super
+    end
+
+    def free(*)
+      super
+    end
+
+    # This function terminates the gr3 context.
+    def terminate(*)
+      super
+    end
+
+    # This function returns information on the most recent GR3 error.
+    def geterror(*)
+      super
+    end
+
+    # This function allows the user to find out how his commands are rendered.
+    def getrenderpathstring(*)
+      super
+    end
+
+    # This function returns a string representation of a given error code.
+    def geterrorstring(*)
+      super
+    end
+
+    # This function clears the draw list.
+    def clear(*)
+      super
+    end
+
+    def usecurrentframebuffer(*)
+      super
+    end
+
+    def useframebuffer(*)
+      super
+    end
+
+    def setquality(*)
+      super
+    end
+
+    # getimage
+    def getimage(width, height, use_alpha = true)
+      bpp = use_alpha ? 4 : 3
+      inquiry(uint8: width * height * bpp) do |bitmap|
+        super(width, height, (use_alpha ? 1 : 0), bitmap)
+      end
+    end
+
+    def export(*)
+      super
+    end
+
+    def drawimage(*)
+      super
+    end
+
+    # createmesh_nocopy
     def createmesh_nocopy(_n, vertices, normals, colors)
       inquiry_int do |mesh|
         super(mesh, vertices, normals, colors)
       end
     end
 
+    # This function creates a int from vertex position, normal and color data.
     def createmesh(_n, vertices, normals, colors)
       inquiry_int do |mesh|
         super(mesh, vertices, normals, colors)
       end
     end
 
+    # This function creates a mesh from vertex position, normal and color data.
     def createindexedmesh_nocopy(num_vertices, vertices, normals, colors, num_indices, indices)
       inquiry_int do |mesh|
         super(mesh, num_vertices, vertices, normals, colors, num_indices, indices)
       end
     end
 
+    # This function creates a int from vertex position, normal and color data.
     def createindexedmesh(num_vertices, vertices, normals, colors, num_indices, indices)
       inquiry_int do |mesh|
         super(mesh, num_vertices, vertices, normals, colors, num_indices, indices)
       end
     end
 
-    def getimage(width, height, use_alpha = true)
-      bpp = use_alpha ? 4 : 3
-      inquiry(uint8: width * height * bpp) do |bitmap|
-        super(width, height, (use_alpha ? 1 : 0), bitmap)
-      end
+    # This function adds a mesh to the draw list, so it will be drawn when the user calls gr3_getpixmap.
+    def drawmesh(*)
+      super
+    end
+
+    # This function marks a mesh for deletion and removes the user’s reference from the mesh’s referenc counter,
+    # so a user must not use the mesh after calling this function.
+    def deletemesh(*)
+      super
+    end
+
+    # This function sets the view matrix by getting the position of the camera,
+    # the position of the center of focus and the direction which should point up.
+    def cameralookat(*)
+      super
+    end
+
+    # This function sets the projection parameters.
+    def setcameraprojectionparameters(*)
+      super
+    end
+
+    # Get the projection parameters.
+    def getcameraprojectionparameters(*)
+      super
+    end
+
+    # This function sets the direction of light.
+    def setlightdirection(*)
+      super
+    end
+
+    # This function sets the background color.
+    def setbackgroundcolor(*)
+      super
+    end
+
+    def createheightmapmesh(*)
+      super
+    end
+
+    def drawheightmap(*)
+      super
     end
 
-    # gr3_gr
+    def drawconemesh(*)
+      super
+    end
 
+    def drawcylindermesh(*)
+      super
+    end
+
+    def drawspheremesh(*)
+      super
+    end
+
+    def drawcubemesh(*)
+      super
+    end
+
+    def setobjectid(*)
+      super
+    end
+
+    def selectid(*)
+      super
+    end
+
+    def getviewmatrix(*)
+      super
+    end
+
+    def setviewmatrix(*)
+      super
+    end
+
+    def getprojectiontype(*)
+      super
+    end
+
+    def setprojectiontype(*)
+      super
+    end
+
+    # This function creates an isosurface from voxel data using the
+    # marching cubes algorithm.
+    # Returns a mesh.
+    def createisosurfacemesh(grid, step, offset, isolevel)
+      dim_x, dim_y, dim_z = grid.shape
+      step_x, step_y, step_z = step
+      offset_x, offset_y, offset_z = offset
+      # NArray does not have the strides method
+      bytesize = grid.class.byte_size
+      stride_x =  1
+      stride_y =  dim_y
+      stride_z =  dim_y * dim_z
+      # stride_x, stride_y, stride_z = stride
+      inquiry_int do |mesh|
+        super(mesh, uint16(grid), isolevel, dim_x, dim_y, dim_z,
+        stride_x, stride_y, stride_z, step_x, step_y, step_z, offset_x, offset_y, offset_z)
+      end
+    end
+
+    # Create a mesh of a surface plot similar to gr_surface.
     def createsurfacemesh(nx, ny, px, py, pz, option = 0)
       inquiry_int do |mesh|
         super(mesh, nx, ny, px, py, pz, option)
       end
     end
 
-    # gr3_convenience
+    # Draw a mesh with the projection of gr.
+    def drawmesh_grlike(*)
+      super
+    end
 
+    # Convenience function for drawing a surfacemesh.
+    def drawsurface(*)
+      super
+    end
+
+    # Create a surface plot with gr3 and draw it with gks as cellarray.
+    def surface(px, py, pz, _option)
+      nx = px.length
+      ny = py.length
+      # TODO: Check out_of_bounds
+      super(nx, ny, px, py, pz, ption)
+    end
+
+    # drawtubemesh
     def drawtubemesh(n, points, colors, radii, num_steps = 10, num_segments = 20)
       super(n, points, colors, radii, num_steps, num_segments)
     end
+
+    # createtubemesh
+    def createtubemesh(n, points, colors, radii, num_steps = 10, num_segments = 20)
+      inquiry_uint do |mesh| # mesh should be Int?
+        super(mesh, n, points, colors, radii, num_steps, num_segments)
+      end
+    end
+
+    # drawspins
+    def drawspins(positions, directions, colors = nil,
+                  cone_radius = 0.4, cylinder_radius = 0.2,
+                  cone_height = 1.0, cylinder_height = 1.0)
+      n = positions.length
+      colors = [1] * n * 3 if colors.nil?
+      super(n, positions, directions, colors, cone_radius, cylinder_radius, cone_height, cylinder_height)
+    end
+
+    # drawmolecule
+    def drawmolecule(positions, colors = nil, radii = nil, spins = nil,
+                     bond_radius = nil, bond_color = nil, bond_delta = nil,
+                     set_camera = true, rotation = 0, tilt = 0)
+      # Should `drawmolecule` take keyword arguments?
+      # Setting default values later for now.
+
+      # Should it be RubyArray instead of Narray?
+      # If NArray is required, add no NArray error.
+      positions = Numo::SFloat.cast(positions)
+      n = positions.shape[0]
+
+      colors = if colors.nil?
+                 Numo::SFloat.ones(n, 3)
+               else
+                 Numo::SFloat.cast(colors).reshape(n, 3)
+               end
+
+      radii = if radii.nil?
+                Numo::SFloat.new(n).fill(0.3)
+              else
+                Numo::SFloat.cast(radii).reshape(n)
+              end
+
+      bond_color ||= [0.8, 0.8, 0.8]
+      bond_color = Numo::SFloat.cast(bond_color).reshape(3)
+      bond_delta ||= 1.0
+      bond_radius ||= 0.1
+
+      if set_camera
+        deg2rad = ->(degree) { degree * Math::PI / 180 } # room for improvement
+        cx, cy, cz = *positions.mean(axis: 0)
+        dx, dy, dz = *positions.ptp(axis: 0)
+        d = [dx, dy].max / 2 / 0.4142 + 3
+        r = dz / 2 + d
+        rx = r * Math.sin(deg2rad.call(tilt)) * Math.sin(deg2rad.call(rotation))
+        ry = r * Math.sin(deg2rad.call(tilt)) * Math.cos(deg2rad.call(rotation))
+        rz = r * Math.cos(deg2rad.call(tilt))
+        ux = Math.sin(deg2rad.call(tilt + 90)) * Math.sin(deg2rad.call(rotation))
+        uy = Math.sin(deg2rad.call(tilt + 90)) * Math.cos(deg2rad.call(rotation))
+        uz = Math.cos(deg2rad.call(tilt + 90))
+        cameralookat(cx + rx, cy + ry, cz + rz, cx, cy, cz, ux, uy, uz)
+        setcameraprojectionparameters(45, d - radii.max - 3, d + dz + radii.max + 3)
+      end
+
+      super(n, positions, colors, radii, bond_radius, bond_color, bond_delta)
+
+      if spins
+        spins = Numo::SFloat.cast(spins).reshape(n, 3)
+        drawspins(positions, spins, colors)
+      end
+    end
+
+    # Creates meshes for slices through the given data, using the current GR
+    # colormap. Use the parameters x, y or z to specify what slices should be
+    # drawn and at which positions they should go through the data. If neither
+    # x nor y nor z are set, 0.5 will be used for all three.
+    # Returns meshes for the yz-slice, the xz-slice and the xy-slice.
+    def createslicemeshes(grid, x = nil, y = nil, z = nil, step = nil, offset = nil)
+      if [x, y, z].all?(&:nil?)
+        x = 0.5
+        y = 0.5
+        z = 0.5
+      end
+      _mesh_x = (createxslicemesh(grid, x, step, offset) if x)
+      _mesh_y = (createyslicemesh(grid, y, step, offset) if y)
+      _mesh_z = (createzslicemesh(grid, z, step, offset) if z)
+      [_mesh_x, _mesh_y, _mesh_z]
+    end
+
+    def preprocess_createslicemesh(grid, step, offset)
+      # TODO: raise error when grid is not narray
+      # grid
+      case grid.class::MAX
+      when Integer
+        input_max = grid.class::MAX
+      when Float
+        # floating point values are expected to be in range [0, 1]
+        # Complex narrays are not taken into account
+        input_max = 1
+        grid[grid > 1] = 1
+      else
+        raise ArgumentError, 'grid must be three dimensional array of Real numbers'
+      end
+      scaling_factor = Numo::UInt16::MAX / input_max.to_f
+      grid = (grid.cast_to(Numo::UInt64) * scaling_factor).cast_to(Numo::UInt16) # room for improvement
+
+      # step & offset
+      nx, ny, nz = grid.shape
+      if step.nil? && offset.nil?
+        step = [2.0 / (nx - 1), 2.0 / (ny - 1), 2.0 / (nz - 1)]
+        offset = [-1.0, -1.0, -1.0]
+      elsif offset.nil?
+        offset = [-step[0] * (nx - 1) / 2.0,
+                  -step[1] * (ny - 1) / 2.0,
+                  -step[2] * (nz - 1) / 2.0]
+      elsif step.nil?
+        step = [-offset[0] * 2.0 / (nx - 1),
+                -offset[1] * 2.0 / (ny - 1),
+                -offset[2] * 2.0 / (nz - 1)]
+      end
+
+      step_x, step_y, step_z = step
+      offset_x, offset_y, offset_z = offset
+
+      [grid, nx, ny, nz, step_x, step_y, step_z, offset_x, offset_y, offset_z]
+    end
+
+    # Creates a meshes for a slices through the yz-plane of the given data,
+    # using the current GR colormap. Use the x parameter to set the position of
+    # the yz-slice.
+    # Returns a mesh for the yz-slice.
+    def createxslicemesh(grid, x = 0.5, step = nil, offset = nil)
+      grid, nx, ny, nz, step_x, step_y, step_z, offset_x, offset_y, offset_z = preprocess_createslicemesh(grid, step, offset)
+      x = (x.clamp(0, 1) * nx).floor
+      stride_x = 1
+      stride_y = ny
+      stride_z = ny * nz
+      inquiry_int do |mesh|
+        super(mesh, grid, x, nx, ny, nz, stride_x, stride_y, stride_z,
+              step_x, step_y, step_z, offset_x, offset_y, offset_z)
+      end
+    end
+
+    # Creates a meshes for a slices through the xz-plane of the given data,
+    # using the current GR colormap. Use the y parameter to set the position of
+    # the xz-slice.
+    # Returns a mesh for the xz-slice.
+    def createyslicemesh(grid, y = 0.5, step = nil, offset = nil)
+      grid, nx, ny, nz, step_x, step_y, step_z, offset_x, offset_y, offset_z = preprocess_createslicemesh(grid, step, offset)
+      y = (y.clamp(0, 1) * ny).floor
+      stride_x = nx
+      stride_y = 1
+      stride_z = nx * nz
+      inquiry_int do |mesh|
+        super(mesh, grid, y, nx, ny, nz, stride_x, stride_y, stride_z,
+              step_x, step_y, step_z, offset_x, offset_y, offset_z)
+      end
+    end
+
+    # Creates a meshes for a slices through the xy-plane of the given data,
+    # using the current GR colormap. Use the z parameter to set the position of
+    # the xy-slice.
+    # Returns a mesh for the xy-slice.
+    def createzslicemesh(grid, z = 0.5, step = nil, offset = nil)
+      grid, nx, ny, nz, step_x, step_y, step_z, offset_x, offset_y, offset_z = preprocess_createslicemesh(grid, step, offset)
+      z = (z.clamp(0, 1) * nz).floor
+      stride_x = ny * nz
+      stride_y = ny
+      stride_z = 1
+      inquiry_int do |mesh|
+        super(mesh, grid, z, nx, ny, nz, stride_x, stride_y, stride_z,
+              step_x, step_y, step_z, offset_x, offset_y, offset_z)
+      end
+    end
+
+    # Draw a yz-slice through the given data, using the current GR colormap.
+    def drawxslicemesh(grid, x = 0.5, step = nil, offset = nil,
+                       position = [0, 0, 0], direction = [0, 0, 1], up = [0, 1, 0],
+                       color = [1, 1, 1], scale = [1, 1, 1])
+      mesh = createxslicemesh(grid, x, step, offset)
+      drawmesh(mesh, 1, position, direction, up, color, scale)
+      deletemesh(mesh)
+    end
+
+    # Draw a xz-slice through the given data, using the current GR colormap.
+    def drawyslicemesh(grid, y = 0.5, step = nil, offset = nil,
+                       position = [0, 0, 0], direction = [0, 0, 1], up = [0, 1, 0],
+                       color = [1, 1, 1], scale = [1, 1, 1])
+      mesh = createyslicemesh(grid, y, step, offset)
+      drawmesh(mesh, 1, position, direction, up, color, scale)
+      deletemesh(mesh)
+    end
+
+    # Draw a xy-slice through the given data, using the current GR colormap.
+    def drawzslicemesh(grid, z = 0.5, step = nil, offset = nil,
+                       position = [0, 0, 0], direction = [0, 0, 1], up = [0, 1, 0],
+                       color = [1, 1, 1], scale = [1, 1, 1])
+      mesh = createzslicemesh(grid, z, step, offset)
+      drawmesh(mesh, 1, position, direction, up, color, scale)
+      deletemesh(mesh)
+    end
+
+    # raw slices through the given data, using the current GR colormap.
+    # Use the parameters x, y or z to specify what slices should be drawn and at
+    # which positions they should go through the data. If neither x nor y nor
+    # z are set, 0.5 will be used for all three.
+    def drawslicemeshes(grid, x = nil, y = nil, z = nil, step = nil,
+                        offset = nil, position = [0, 0, 0], direction = [0, 0, 1], up = [0, 1, 0],
+                        color = [1, 1, 1], scale = [1, 1, 1])
+      meshes = createslicemeshes(grid, x, y, z, step, offset)
+      meshes.each do |mesh|
+        if mesh
+          drawmesh(mesh, 1, position, direction, up, color, scale)
+          deletemesh(mesh)
+        end
+      end
+    end
+
+    def volume(data, algorithm)
+      inquiry %i[double double] do |dmin, dmax|
+        amin.write_double(-1)
+        dmax.write_double(-1)
+        # TODO: raise error when no NArray
+        data = Numo::DFloat.cast(data) if data.is_a Array
+        nx, ny, nz = data.shape
+        super(nx, ny, nz, data, algorithm, dmin, dmax)
+      end
+    end
   end
 
   # Constants - imported from GR.jl
@@ -134,4 +540,94 @@ module GR3
   SURFACE_GRTRANSFORM =  4
   SURFACE_GRCOLOR     =  8
   SURFACE_GRZSHADED   = 16
+
+  ATOM_COLORS =
+    [[0, 0, 0],
+     [255, 255, 255], [217, 255, 255], [204, 128, 255],
+     [194, 255, 0], [255, 181, 181], [144, 144, 144],
+     [48, 80, 248], [255, 13, 13], [144, 224, 80],
+     [179, 227, 245], [171, 92, 242], [138, 255, 0],
+     [191, 166, 166], [240, 200, 160], [255, 128, 0],
+     [255, 255, 48], [31, 240, 31], [128, 209, 227],
+     [143, 64, 212], [61, 225, 0], [230, 230, 230],
+     [191, 194, 199], [166, 166, 171], [138, 153, 199],
+     [156, 122, 199], [224, 102, 51], [240, 144, 160],
+     [80, 208, 80], [200, 128, 51], [125, 128, 176],
+     [194, 143, 143], [102, 143, 143], [189, 128, 227],
+     [225, 161, 0], [166, 41, 41], [92, 184, 209],
+     [112, 46, 176], [0, 255, 0], [148, 255, 255],
+     [148, 224, 224], [115, 194, 201], [84, 181, 181],
+     [59, 158, 158], [36, 143, 143], [10, 125, 140],
+     [0, 105, 133], [192, 192, 192], [255, 217, 143],
+     [166, 117, 115], [102, 128, 128], [158, 99, 181],
+     [212, 122, 0], [148, 0, 148], [66, 158, 176],
+     [87, 23, 143], [0, 201, 0], [112, 212, 255],
+     [255, 255, 199], [217, 225, 199], [199, 225, 199],
+     [163, 225, 199], [143, 225, 199], [97, 225, 199],
+     [69, 225, 199], [48, 225, 199], [31, 225, 199],
+     [0, 225, 156], [0, 230, 117], [0, 212, 82],
+     [0, 191, 56], [0, 171, 36], [77, 194, 255],
+     [77, 166, 255], [33, 148, 214], [38, 125, 171],
+     [38, 102, 150], [23, 84, 135], [208, 208, 224],
+     [255, 209, 35], [184, 184, 208], [166, 84, 77],
+     [87, 89, 97], [158, 79, 181], [171, 92, 0],
+     [117, 79, 69], [66, 130, 150], [66, 0, 102],
+     [0, 125, 0], [112, 171, 250], [0, 186, 255],
+     [0, 161, 255], [0, 143, 255], [0, 128, 255],
+     [0, 107, 255], [84, 92, 242], [120, 92, 227],
+     [138, 79, 227], [161, 54, 212], [179, 31, 212],
+     [179, 31, 186], [179, 13, 166], [189, 13, 135],
+     [199, 0, 102], [204, 0, 89], [209, 0, 79],
+     [217, 0, 69], [224, 0, 56], [230, 0, 46],
+     [235, 0, 38], [255, 0, 255], [255, 0, 255],
+     [255, 0, 255], [255, 0, 255], [255, 0, 255],
+     [255, 0, 255], [255, 0, 255], [255, 0, 255],
+     [255, 0, 255]].map! { |i| i.map! { |j| j / 255.0 } }
+
+  atom_number = {}
+  { H: 1, HE: 2, LI: 3, BE: 4, B: 5, C: 6, N: 7,
+    O: 8, F: 9, NE: 10, NA: 11, MG: 12, AL: 13,
+    SI: 14, P: 15, S: 16, CL: 17, AR: 18, K: 19,
+    CA: 20, SC: 21, TI: 22, V: 23, CR: 24, MN: 25,
+    FE: 26, CO: 27, NI: 28, CU: 29, ZN: 30, GA: 31,
+    GE: 32, AS: 33, SE: 34, BR: 35, KR: 36, RB: 37,
+    SR: 38, Y: 39, ZR: 40, NB: 41, MO: 42, TC: 43,
+    RU: 44, RH: 45, PD: 46, AG: 47, CD: 48, IN: 49,
+    SN: 50, SB: 51, TE: 52, I: 53, XE: 54, CS: 55,
+    BA: 56, LA: 57, CE: 58, PR: 59, ND: 60, PM: 61,
+    SM: 62, EU: 63, GD: 64, TB: 65, DY: 66, HO: 67,
+    ER: 68, TM: 69, YB: 70, LU: 71, HF: 72, TA: 73,
+    W: 74, RE: 75, OS: 76, IR: 77, PT: 78, AU: 79,
+    HG: 80, TL: 81, PB: 82, BI: 83, PO: 84, AT: 85,
+    RN: 86, FR: 87, RA: 88, AC: 89, TH: 90, PA: 91,
+    U: 92, NP: 93, PU: 94, AM: 95, CM: 96, BK: 97,
+    CF: 98, ES: 99, FM: 100, MD: 101, NO: 102,
+    LR: 103, RF: 104, DB: 105, SG: 106, BH: 107,
+    HS: 108, MT: 109, DS: 110, RG: 111, CN: 112,
+    UUB: 112, UUT: 113, UUQ: 114, UUP: 115, UUH: 116,
+    UUS: 117, UUO: 118 }.each do |key, value|
+      atom_number[key] = value
+      atom_number[key.to_s] = value # allow string keys
+    end
+  ATOM_NUMBERS = atom_number.freeze
+
+  ATOM_VALENCE_RADII =
+    [0, # Avoid atomic number to index conversion
+     230, 930, 680, 350, 830, 680, 680, 680, 640,
+     1120, 970, 1100, 1350, 1200, 750, 1020, 990,
+     1570, 1330, 990, 1440, 1470, 1330, 1350, 1350,
+     1340, 1330, 1500, 1520, 1450, 1220, 1170, 1210,
+     1220, 1210, 1910, 1470, 1120, 1780, 1560, 1480,
+     1470, 1350, 1400, 1450, 1500, 1590, 1690, 1630,
+     1460, 1460, 1470, 1400, 1980, 1670, 1340, 1870,
+     1830, 1820, 1810, 1800, 1800, 1990, 1790, 1760,
+     1750, 1740, 1730, 1720, 1940, 1720, 1570, 1430,
+     1370, 1350, 1370, 1320, 1500, 1500, 1700, 1550,
+     1540, 1540, 1680, 1700, 2400, 2000, 1900, 1880,
+     1790, 1610, 1580, 1550, 1530, 1510, 1500, 1500,
+     1500, 1500, 1500, 1500, 1500, 1500, 1600, 1600,
+     1600, 1600, 1600, 1600, 1600, 1600, 1600, 1600,
+     1600, 1600, 1600, 1600, 1600, 1600].map { |i| i / 1000.0 }
+
+  ATOM_RADII = ATOM_VALENCE_RADII.map { |i| i * 0.4 }
 end