GeoRuby 1.1.2 → 1.2.0

data/README

@@ -1,5 +1,5 @@
 =GeoRuby
-This is GeoRuby 1.1.0. It is intended as a holder for data returned from PostGIS and the Spatial Extensions of MySql. The data model roughly follows the OGC "Simple Features for SQL" specification (see http://www.opengis.org/docs/99-049.pdf), although without any kind of advanced functionalities (such as geometric operators or reprojections). 
+This is GeoRuby 1.2.0. It is intended as a holder for data returned from PostGIS and the Spatial Extensions of MySql. The data model roughly follows the OGC "Simple Features for SQL" specification (see http://www.opengis.org/docs/99-049.pdf), although without any kind of advanced functionalities (such as geometric operators or reprojections). 
 
 ===Available data types
 The following geometric data types are provided :
@@ -19,29 +19,32 @@ On top of this an Envelope class is available, to contain the bounding box of a
 ===Input and output
 These geometries can be input and output in WKB/EWKB/WKT/EWKT format (as well as the related HexWKB and HexEWKB formats). HexEWKB and WKB are the default form under which geometric data is returned respectively from PostGIS and MySql.
 
-GeoRSS Simple, GeoRSS W3CGeo, GeoRSS GML can also be input and output. Note that they will not output valid RSS, but just the part strictly concerning the geometry as outlined in http://www.georss.org/1/ . Since the model does not allow multiple geometries, for geometry collections, only the first geometry will be output. Similarly, for polygons, the GeoRSS output will only contain the outer ring. As for W3CGeo output, only points can be output, so the first point of the geometry is chosen. By default the Simple format is output. Envelope can also be output in these formats: The box geometric type is chosen (except for W3CGeo, where the center of the envelope is chose). 
+GeoRSS Simple, GeoRSS W3CGeo, GeoRSS GML can also be input and output. Note that they will not output valid RSS, but just the part strictly concerning the geometry as outlined in http://www.georss.org/1/ . Since the model does not allow multiple geometries, for geometry collections, only the first geometry will be output. Similarly, for polygons, the GeoRSS output will only contain the outer ring. As for W3CGeo output, only points can be output, so the first point of the geometry is chosen. By default the Simple format is output. Envelope can also be output in these formats: The box geometric type is chosen (except for W3CGeo, where the center of the envelope is chose). These formats can also be input and a GeoRuby geometry will be created. Note that it will not read a valid RSS file, only a geometry string.
 
 On top of that, there is now support for KML output. As for GeoRSS, a valid KML file will not be output, but only the geometric data. Options <tt>:id</tt>, <tt>:extrude</tt>, <tt>:tesselate</tt> and <tt>:altitude_mode</tt> can be given. Note that if the <tt>:altitude_mode</tt> option is not passed or set to <tt>clampToGround</tt>, the altitude data will not be output even if present. Envelopes output a LatLonAltBox instead of a geometry.
 
+===SHP Reading
+Support for reading ESRI shapefiles (http://www.esri.com/library/whitepapers/pdfs/shapefile.pdf) has been added. A tool called <tt>shp2sql.rb</tt> is also provided : it shows how to use the SHP reading functionality together with the spatial adapter plugin for Rails to import spatial features into MySQL and PostGIS.
+
 ===Installation
 To install the latest version, just type :
       gem install GeoRuby
 
 ===Changes since the last version
-- Input of GeoRSS geometries (1.1.1)
-- Addition of the Vincenty ellipsoidal distance calculation method
-- The spherical distance now assumes the x and y are in degrees not radians
-- Addition of aliases to the +x+ and +y+ accessors, as well as the <tt>from_x_y_...</tt> constructors so the +x+ can be replaced by +lon+ and +y+ by +lat+.
-- Output of GeoRSS Simple, W3CGeo and GML formats
-- Output of KML format
-
-===For version 1.2.0
-- Reading (and writing?) of SHP files
+- Reading of ESRI shapefiles
+- Addition of a small tool to import spatial features in MySQL and PostGIS from a SHP file
+
+===Coming in the next versions
+- Writing of SHP files
+- Better shp2sql import tool
 - Documentation
-- Update of the tutorials to show the GeoRSS and KML output, as well as the reading of SHP files
+- Geometric operators
+
+===Acknowledgement
+The SHP reading part uses a modified version of the DBF library (http://rubyforge.org/projects/dbf/) by Keith Morrison (http://infused.org).
 
 ===License
 GeoRuby is released under the MIT license.
 
 ===Support
-Any questions, enhancement proposals, bug notifications or corrections can be sent to mailto:guilhem.vellut+georuby@gmail.com.
+Any questions, enhancement proposals, bug notifications or corrections can be sent to mailto:guilhem.vellut@gmail.com.

data/lib/geo_ruby/shp4r/dbf.rb

@@ -0,0 +1,234 @@
+# Copyright 2006 Keith Morrison (http://infused.org)
+# Modified version of his DBF library (http://rubyforge.org/projects/dbf/)
+
+module GeoRuby
+  module Shp4r 
+    module Dbf
+      
+      DBF_HEADER_SIZE = 32
+      FPT_HEADER_SIZE = 512
+      FPT_BLOCK_HEADER_SIZE = 8
+      DATE_REGEXP = /([\d]{4})([\d]{2})([\d]{2})/
+      VERSION_DESCRIPTIONS = {
+        "02" => "FoxBase",
+        "03" => "dBase III without memo file",
+        "04" => "dBase IV without memo file",
+        "05" => "dBase V without memo file",
+        "30" => "Visual FoxPro",
+        "31" => "Visual FoxPro with AutoIncrement field",
+        "7b" => "dBase IV with memo file",
+        "83" => "dBase III with memo file",
+        "8b" => "dBase IV with memo file",
+        "8e" => "dBase IV with SQL table",
+        "f5" => "FoxPro with memo file",
+        "fb" => "FoxPro without memo file"
+      }
+      
+      class DBFError < StandardError; end
+      class UnpackError < DBFError; end
+      
+      class Reader
+        attr_reader :field_count
+        attr_reader :fields
+        attr_reader :record_count
+        attr_reader :version
+        attr_reader :last_updated
+        
+        def initialize(file)
+          @data_file = File.open(file, 'rb')
+          @memo_file = open_memo(file)
+          reload!
+        end
+
+        def self.open(file)
+          reader = Reader.new(file)
+          if block_given?
+            yield reader
+            reader.close
+          else
+            reader
+          end
+        end
+
+        def close
+          @data_file.close
+        end
+        
+        def reload!
+          get_header_info
+          get_memo_header_info if @memo_file
+          get_field_descriptors
+        end
+        
+        def has_memo_file?
+          @memo_file ? true : false
+        end
+        
+        def open_memo(file)
+          %w(fpt FPT dbt DBT).each do |extension|
+            filename = file.sub(/dbf$/i, extension)
+            if File.exists?(filename)
+              @memo_file_format = extension.downcase.to_sym
+              return File.open(filename, 'rb')
+            end
+          end
+          nil
+        end
+        
+        def field(field_name)
+          @fields.detect {|f| f.name == field_name.to_s}
+        end
+        
+        def memo(start_block)
+          @memo_file.rewind
+          @memo_file.seek(start_block * @memo_block_size)
+          if @memo_file_format == :fpt
+            memo_type, memo_size, memo_string = @memo_file.read(@memo_block_size).unpack("NNa56")
+            if memo_size > @memo_block_size - FPT_BLOCK_HEADER_SIZE
+              memo_string << @memo_file.read(memo_size - @memo_block_size + FPT_BLOCK_HEADER_SIZE)
+            end
+          else
+            if version == "83" # dbase iii
+              memo_string = ""
+              loop do
+                memo_string << block = @memo_file.read(512)
+                break if block.strip.size < 512
+              end
+            elsif version == "8b" # dbase iv
+              memo_type, memo_size = @memo_file.read(8).unpack("LL")
+              memo_string = @memo_file.read(memo_size)
+            end
+          end
+          memo_string
+        end
+        
+        # An array of all the records contained in the database file
+        def records
+          seek_to_record(0)
+          @records ||= Array.new(@record_count) do |i|
+            if active_record?
+              build_record
+            else
+              seek_to_record(i + 1)
+              nil
+            end
+          end
+        end
+        
+        alias_method :rows, :records
+        
+        # Jump to record
+        def record(index)
+          seek_to_record(index)
+          active_record? ? build_record : nil
+        end
+        
+        alias_method :row, :record
+        
+        def version_description
+          VERSION_DESCRIPTIONS[version]
+        end
+        
+        private
+        
+        def active_record?
+          @data_file.read(1).unpack('H2').to_s == '20' rescue false
+        end
+                
+        def build_record
+          record = DbfRecord.new
+          @fields.each do |field| 
+            case field.type
+            when 'N'
+              record[field.name] = unpack_integer(field) rescue nil
+            when 'F'
+              record[field.name] = unpack_float(field) rescue nil
+            when 'D'
+              raw = unpack_string(field).to_s.strip
+              unless raw.empty?
+                begin
+                  record[field.name] = Time.gm(*raw.match(DATE_REGEXP).to_a.slice(1,3).map {|n| n.to_i})
+                rescue
+                  record[field.name] = Date.new(*raw.match(DATE_REGEXP).to_a.slice(1,3).map {|n| n.to_i}) rescue nil
+                end
+              end
+            when 'M'
+              starting_block = unpack_integer(field)
+              record[field.name] = starting_block == 0 ? nil : memo(starting_block) rescue nil
+            when 'L'
+              record[field.name] = unpack_string(field) =~ /^(y|t)$/i ? true : false rescue false
+            when 'C'
+              record[field.name] = unpack_string(field).strip
+            else
+              record[field.name] = unpack_string(field)
+            end
+          end
+          record
+        end
+        
+        def get_header_info
+          @data_file.rewind
+          @version, @record_count, @header_length, @record_length = @data_file.read(DBF_HEADER_SIZE).unpack('H2xxxVvv')
+          @field_count = (@header_length - DBF_HEADER_SIZE + 1) / DBF_HEADER_SIZE
+        end
+        
+        def get_field_descriptors
+          @fields = Array.new(@field_count) {|i| Field.new(*@data_file.read(32).unpack('a10xax4CC'))}
+        end
+        
+        def get_memo_header_info
+          @memo_file.rewind
+          if @memo_file_format == :fpt
+            @memo_next_available_block, @memo_block_size = @memo_file.read(FPT_HEADER_SIZE).unpack('Nxxn')
+          else
+            @memo_block_size = 512
+            @memo_next_available_block = File.size(@memo_file.path) / @memo_block_size
+          end
+        end
+        
+        def seek(offset)
+          @data_file.seek(@header_length + offset)
+        end
+        
+        def seek_to_record(index)
+          seek(@record_length * index)
+        end
+        
+        def unpack_field(field)
+          @data_file.read(field.length).unpack("a#{field.length}")
+        end
+        
+        def unpack_string(field)
+          unpack_field(field).to_s
+        end
+        
+        def unpack_integer(field)
+          unpack_string(field).to_i
+        end
+        
+        def unpack_float(field)
+          unpack_string(field).to_f
+        end
+        
+      end
+      
+      class FieldError < StandardError; end
+      
+      class Field
+        attr_reader :name, :type, :length, :decimal
+
+        def initialize(name, type, length, decimal)
+          raise FieldError, "field length must be greater than 0" unless length > 0
+          if type == 'N' and decimal != 0
+            type = 'F'
+          end
+          @name, @type, @length, @decimal = name.strip, type,length, decimal
+        end
+      end
+      
+      class DbfRecord < Hash
+      end
+      
+    end
+  end
+end

data/lib/geo_ruby/shp4r/shp.rb

@@ -0,0 +1,301 @@
+require  File.dirname(__FILE__) + '/dbf'
+
+module GeoRuby
+  module Shp4r
+    
+    #Enumerates all the types of SHP geometries. The MULTIPATCH one is the only one not currently supported by GeoRuby.
+    module ShpType
+      NULL_SHAPE = 0
+      POINT = 1
+      POLYLINE = 3
+      POLYGON = 5
+      MULTIPOINT = 8
+      POINTZ = 11
+      POLYLINEZ = 13
+      POLYGONZ = 15
+      MULTIPOINTZ = 18
+      POINTM = 21
+      POLYLINEM = 23
+      POLYGONM = 25
+      MULTIPOINTM = 28
+      MULTIPATCH = 31 #not supported here
+    end
+    
+    #An interface to an ESRI shapefile (actually 3 files : shp, shx and dbf). Currently supports only the reading of geometries.
+    class ShpFile
+      attr_reader :shp_type, :record_count, :xmin, :ymin, :xmax, :ymax, :zmin, :zmax, :mmin, :mmax
+
+      #Opens a SHP file. Both "abc.shp" and "abc" are accepted. The files "abc.shp", "abc.shx" and "abc.dbf" must be present
+      def initialize(file, access = "r")
+        #strip the shp out of the file if present
+        file = file.gsub(/.shp$/i,"")
+        #check existence of shp, dbf and shx files       
+        unless File.exists?(file + ".shp") and File.exists?(file + ".dbf") and File.exists?(file + ".shx")
+          raise MalformedShpException.new("Missing one of shp, dbf or shx for: #{file}")
+        end
+
+        @dbf = Dbf::Reader.open(file + ".dbf")
+        @shx = File.open(file + ".shx","rb")
+        @shp = File.open(file + ".shp","rb")
+        read_index
+      end
+      
+      #opens a SHP "file". If a block is given, the ShpFile object is yielded to it and is closed upon return. Else a call to <tt>open</tt> is equivalent to <tt>ShpFile.new(...)</tt>.
+      def self.open(file,access = "r")
+        shpfile = ShpFile.new(file,access)
+        if block_given?
+          yield shpfile
+          shpfile.close
+        else
+          shpfile
+        end
+      end
+      
+      #Closes a shapefile
+      def close
+        @dbf.close
+        @shx.close
+        @shp.close
+      end
+      
+      #return the description of data fields
+      def fields
+        @dbf.fields
+      end
+      
+      #Tests if the file has no record
+      def empty?
+        record_count == 0
+      end
+      
+      #Goes through each record
+      def each
+        (0...record_count).each do |i|
+          yield get_record(i)
+        end
+      end
+      alias :each_record :each
+      
+      #Returns record +i+
+      def [](i)
+        get_record(i)
+      end
+
+      #Returns all the records
+      def records
+        Array.new(record_count) do |i|
+          get_record(i)
+        end
+      end
+
+      private   
+      def read_index
+        file_length, @shp_type, @xmin, @ymin, @xmax, @ymax, @zmin, @zmax, @mmin,@mmax = @shx.read(100).unpack("x24Nx4VE8")
+        @record_count = (file_length - 50) / 4
+        unless @record_count == @dbf.record_count
+          raise MalformedShpException.new("Not the same number of records in SHP and DBF")
+        end
+      end
+
+      #TODO : refactor to minimize redundant code
+      def get_record(i)
+        return nil if record_count <= i or i < 0
+        dbf_record = @dbf.record(i)
+        @shx.seek(100 + 8 * i) #100 is the header length
+        offset,length = @shx.read(8).unpack("N2")
+        @shp.seek(offset * 2 + 8)
+        rec_shp_type = @shp.read(4).unpack("V")[0]
+
+        case(rec_shp_type)
+        when ShpType::POINT
+          x, y = @shp.read(16).unpack("E2")
+          geometry = GeoRuby::SimpleFeatures::Point.from_x_y(x,y)
+
+
+        when ShpType::POLYLINE #actually creates a multi_polyline
+          @shp.seek(32,IO::SEEK_CUR) #extent 
+          num_parts, num_points = @shp.read(8).unpack("V2")
+          
+          parts =  @shp.read(num_parts * 4).unpack("V" + num_parts.to_s)
+          parts << num_points #indexes for LS of idx i go to parts of idx i to idx i +1
+          
+          points = Array.new(num_points) do
+            x, y = @shp.read(16).unpack("E2")
+            GeoRuby::SimpleFeatures::Point.from_x_y(x,y)
+          end
+          
+          line_strings = Array.new(num_parts) do |i|
+            GeoRuby::SimpleFeatures::LineString.from_points(points[(parts[i])...(parts[i+1])])
+          end
+          
+          geometry = GeoRuby::SimpleFeatures::MultiLineString.from_line_strings(line_strings)
+
+
+        when ShpType::POLYGON
+          #TODO : TO CORRECT
+          #does not take into account the possibility that the outer loop could be after the inner loops in the SHP + more than one outer loop
+          #Still sends back a multi polygon (so the correction above won't change what gets sent back)
+          @shp.seek(32,IO::SEEK_CUR)
+          num_parts, num_points = @shp.read(8).unpack("V2")
+          parts =  @shp.read(num_parts * 4).unpack("V" + num_parts.to_s)
+          parts << num_points #indexes for LS of idx i go to parts of idx i to idx i +1
+          points = Array.new(num_points) do 
+            x, y = @shp.read(16).unpack("E2")
+            GeoRuby::SimpleFeatures::Point.from_x_y(x,y)
+          end
+          linear_rings = Array.new(num_parts) do |i|
+            GeoRuby::SimpleFeatures::LinearRing.from_points(points[(parts[i])...(parts[i+1])])
+          end
+          geometry = GeoRuby::SimpleFeatures::MultiPolygon.from_polygons([GeoRuby::SimpleFeatures::Polygon.from_linear_rings(linear_rings)])
+
+
+        when ShpType::MULTIPOINT
+          @shp.seek(32,IO::SEEK_CUR)
+          num_points = @shp.read(4).unpack("V")[0]
+          points = Array.new(num_points) do
+            x, y = @shp.read(16).unpack("E2")
+            GeoRuby::SimpleFeatures::Point.from_x_y(x,y)
+          end
+          geometry = GeoRuby::SimpleFeatures::MultiPoint.from_points(points)
+
+
+        when ShpType::POINTZ
+          x, y, z, m = @shp.read(24).unpack("E4")
+          geometry = GeoRuby::SimpleFeatures::Point.from_x_y_z_m(x,y,z,m)
+
+
+        when ShpType::POLYLINEZ
+          @shp.seek(32,IO::SEEK_CUR)
+          num_parts, num_points = @shp.read(8).unpack("V2")
+          parts =  @shp.read(num_parts * 4).unpack("V" + num_parts.to_s)
+          parts << num_points #indexes for LS of idx i go to parts of idx i to idx i +1
+          xys = Array.new(num_points) { @shp.read(16).unpack("E2") }
+          @shp.seek(16,IO::SEEK_CUR)
+          zs = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+          @shp.seek(16,IO::SEEK_CUR)
+          ms = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+          points = Array.new(num_points) do |i|
+            Point.from_x_y_z_m(xys[i][0],xys[i][1],zs[i],ms[i])
+          end
+          line_strings = Array.new(num_parts) do |i|
+            GeoRuby::SimpleFeatures::LineString.from_points(points[(parts[i])...(parts[i+1])],DEFAULT_SRID,true,true)
+          end
+          geometry = GeoRuby::SimpleFeatures::MultiLineString.from_line_strings(line_strings,DEFAULT_SRID,true,true)
+
+          
+        when ShpType::POLYGONZ
+          #TODO : CORRECT
+
+          @shp.seek(32,IO::SEEK_CUR)#extent 
+          num_parts, num_points = @shp.read(8).unpack("V2")
+          parts =  @shp.read(num_parts * 4).unpack("V" + num_parts.to_s)
+          parts << num_points #indexes for LS of idx i go to parts of idx i to idx i +1
+          xys = Array.new(num_points) { @shp.read(16).unpack("E2") }
+          @shp.seek(16,IO::SEEK_CUR)#extent 
+          zs = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+          @shp.seek(16,IO::SEEK_CUR)#extent 
+          ms = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+          points = Array.new(num_points) do |i|
+            Point.from_x_y_z_m(xys[i][0],xys[i][1],zs[i],ms[i])
+          end
+          linear_rings = Array.new(num_parts) do |i|
+            GeoRuby::SimpleFeatures::LinearRing.from_points(points[(parts[i])...(parts[i+1])],DEFAULT_SRID,true,true)
+          end
+          geometry = GeoRuby::SimpleFeatures::MultiPolygon.from_polygons([GeoRuby::SimpleFeatures::Polygon.from_linear_rings(linear_rings)],DEFAULT_SRID,true,true)
+
+
+        when ShpType::MULTIPOINTZ
+          @shp.seek(32,IO::SEEK_CUR)
+          num_points = @shp.read(4).unpack("V")[0]
+          xys = Array.new(num_points) { @shp.read(16).unpack("E2") }
+          @shp.seek(16,IO::SEEK_CUR)
+          zs = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+          @shp.seek(16,IO::SEEK_CUR)
+          ms = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+          
+          points = Array.new(num_points) do |i|
+            Point.from_x_y_z_m(xys[i][0],xys[i][1],zs[i],ms[i])
+          end
+          
+          geometry = GeoRuby::SimpleFeatures::MultiPoint.from_points(points,DEFAULT_SRID,true,true)
+
+        when ShpType::POINTM
+          x, y, m = @shp.read(24).unpack("E3")
+          geometry = GeoRuby::SimpleFeatures::Point.from_x_y_m(x,y,m)
+
+        when ShpType::POLYLINEM
+          @shp.seek(32,IO::SEEK_CUR)
+          num_parts, num_points = @shp.read(8).unpack("V2")
+          parts =  @shp.read(num_parts * 4).unpack("V" + num_parts.to_s)
+          parts << num_points #indexes for LS of idx i go to parts of idx i to idx i +1
+          xys = Array.new(num_points) { @shp.read(16).unpack("E2") }
+          @shp.seek(16,IO::SEEK_CUR)
+          ms = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+          points = Array.new(num_points) do |i|
+            Point.from_x_y_m(xys[i][0],xys[i][1],ms[i])
+          end
+          line_strings = Array.new(num_parts) do |i|
+            GeoRuby::SimpleFeatures::LineString.from_points(points[(parts[i])...(parts[i+1])],DEFAULT_SRID,false,true)
+          end
+          geometry = GeoRuby::SimpleFeatures::MultiLineString.from_line_strings(line_strings,DEFAULT_SRID,false,true)
+
+          
+        when ShpType::POLYGONM
+          #TODO : CORRECT
+
+          @shp.seek(32,IO::SEEK_CUR)
+          num_parts, num_points = @shp.read(8).unpack("V2")
+          parts =  @shp.read(num_parts * 4).unpack("V" + num_parts.to_s)
+          parts << num_points #indexes for LS of idx i go to parts of idx i to idx i +1
+          xys = Array.new(num_points) { @shp.read(16).unpack("E2") }
+          @shp.seek(16,IO::SEEK_CUR)
+          ms = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+          points = Array.new(num_points) do |i|
+            Point.from_x_y_m(xys[i][0],xys[i][1],ms[i])
+          end
+          linear_rings = Array.new(num_parts) do |i|
+            GeoRuby::SimpleFeatures::LinearRing.from_points(points[(parts[i])...(parts[i+1])],DEFAULT_SRID,false,true)
+          end
+          geometry = GeoRuby::SimpleFeatures::MultiPolygon.from_polygons([GeoRuby::SimpleFeatures::Polygon.from_linear_rings(linear_rings)],DEFAULT_SRID,false,true)
+
+
+        when ShpType::MULTIPOINTM
+          @shp.seek(32,IO::SEEK_CUR)
+          num_points = @shp.read(4).unpack("V")[0]
+          xys = Array.new(num_points) { @shp.read(16).unpack("E2") }
+          @shp.seek(16,IO::SEEK_CUR)
+          ms = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+          
+          points = Array.new(num_points) do |i|
+            Point.from_x_y_m(xys[i][0],xys[i][1],ms[i])
+          end
+          
+          geometry = GeoRuby::SimpleFeatures::MultiPoint.from_points(points,DEFAULT_SRID,false,true)
+        else
+          geometry = nil
+        end
+        
+        ShpRecord.new(geometry,dbf_record)
+      end
+    end
+    
+    #A SHP record : contains both the geometry and the data fields (from the DBF)
+    class ShpRecord
+      attr_accessor :geometry , :data
+      
+      def initialize(geometry, data)
+        @geometry = geometry
+        @data = data
+      end
+      
+      #Tests if the geometry is a NULL SHAPE
+      def has_null_shape?
+        @geometry.nil?
+      end
+    end
+
+    class MalformedShpException < StandardError
+    end
+    
+  end
+end