tabula-extractor 0.6.6-java → 0.7.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fa69052647e565cd996f92f1c73e6d00deceea54
+  data.tar.gz: 7d76ccc9b445e9138f65920cd0a401fbee3ababf
+SHA512:
+  metadata.gz: d17ad7e967407711d60d9b30e8d231ab9adef313b8ede84e1960e35f24c5374f472a500e7f7148cc485408f796f1d7a67e96393d0fc5331e0f3f88971dad76c4
+  data.tar.gz: 84121390715280e86fb3ff1dd82533863dfabbb0b27582fb0d3bf9ad088f8d05e4c8f7dfbcfd2f621c232accd6145968e263a4e0e081431cf941939974999b20

data/AUTHORS.md

@@ -13,3 +13,4 @@ Special thanks to these organizations:
 * Knight-Mozilla OpenNews <http://www.mozillaopennews.org/>
 * ProPublica <http://propublica.org>
 * La Nación <http://www.lanacion.com.ar>
+* The New York Times <http://www.nytimes.com>

data/README.md

@@ -17,25 +17,41 @@ jruby -S gem install tabula-extractor
 ## Usage
 
 ```
-$ tabula --help
 Tabula helps you extract tables from PDFs
 
 Usage:
        tabula [options] <pdf_file>
 where [options] are:
-     --page, -p <i>:   Page number (default: 1)
-     --area, -a <s>:   Portion of the page to analyze (top, left, bottom,
-                       right). Example: --area '269.875, 12.75, 790.5, 561'.
-                       Default is entire page
-   --format, -f <s>:   Output format (CSV,TSV,HTML,JSON) (default: CSV)
-  --outfile, -o <s>:   Write output to <file> instead of STDOUT (default: -)
-      --version, -v:   Print version and exit
-         --help, -h:   Show this message
+Tabula helps you extract tables from PDFs
+       --pages, -p <s>:   Comma separated list of ranges. Examples: --pages
+                          1-3,5-7 or --pages 3. Default is --pages 1 (default:
+                          1)
+        --area, -a <s>:   Portion of the page to analyze
+                          (top,left,bottom,right). Example: --area
+                          269.875,12.75,790.5,561. Default is entire page
+     --columns, -c <s>:   X coordinates of column boundaries. Example --columns
+                          10.1,20.2,30.3
+    --password, -s <s>:   Password to decrypt document. Default is empty
+                          (default: )
+           --guess, -g:   Guess the portion of the page to analyze per page.
+           --debug, -d:   Print detected table areas instead of processing.
+      --format, -f <s>:   Output format (CSV,TSV,HTML,JSON) (default: CSV)
+     --outfile, -o <s>:   Write output to <file> instead of STDOUT (default: -)
+     --spreadsheet, -r:   Force PDF to be extracted using spreadsheet-style
+                          extraction (if there are ruling lines separating each
+                          cell, as in a PDF of an Excel spreadsheet)
+  --no-spreadsheet, -n:   Force PDF not to be extracted using spreadsheet-style
+                          extraction (if there are ruling lines separating each
+                          cell, as in a PDF of an Excel spreadsheet)
+          --silent, -i:   Suppress all stderr output.
+         --version, -v:   Print version and exit
+            --help, -h:   Show this message
 ```
 
-Want to integrate `tabula-extractor` into your own application? We don't have docs yet, but [the tests](test/tests.rb) are a good source of information.
+## Scripting examples
+
+`tabula-extractor` is a RubyGem that you can use to programmatically extract tabular data, using the Tabula engine, in your scripts or applications. We don't have docs yet, but [the tests](test/tests.rb) are a good source of information.
 
 ## Notes
 
 `tabula-extractor` uses [LSD: a Line Segment Detector](http://www.ipol.im/pub/art/2012/gjmr-lsd/) by Rafael Grompone von Gioi, Jérémie Jakubowicz, Jean-Michel Morel and Gregory Randall.
-

data/bin/tabula

@@ -34,11 +34,20 @@ EOS
 
     opt :pages, 'Comma separated list of ranges. Examples: --pages 1-3,5-7 or --pages 3. Default is --pages 1', :default => '1', :type => String
     opt :area, 'Portion of the page to analyze (top,left,bottom,right). Example: --area 269.875,12.75,790.5,561. Default is entire page', :type => String, :default => nil
+    opt :columns, 'X coordinates of column boundaries. Example --columns 10.1,20.2,30.3', :default => nil, :type => String
     opt :password, 'Password to decrypt document. Default is empty', :default => ''
-    opt :guess, 'Guess the portion of the page to analyze per page. Slow.'
+    opt :guess, 'Guess the portion of the page to analyze per page.'
     opt :debug, 'Print detected table areas instead of processing.'
     opt :format, "Output format (#{FORMATS.join(",")})", :default => 'CSV'
     opt :outfile, 'Write output to <file> instead of STDOUT', :default => '-'
+    opt :spreadsheet, "Force PDF to be extracted using spreadsheet-style extraction (if there are ruling lines separating each cell, as in a PDF of an Excel spreadsheet)"
+    opt :no_spreadsheet, "Force PDF not to be extracted using spreadsheet-style extraction (if there are ruling lines separating each cell, as in a PDF of an Excel spreadsheet)"
+    opt :silent, 'Suppress all stderr output.'
+  end
+
+  if !opts[:columns].nil?
+    c = opts[:columns].split(',')
+    Trollop::die :columns, "is invalid" unless c.all? { |x| x.strip =~  /(\d+\.?\d*)/ }
   end
 
   if !opts[:area].nil?
@@ -56,31 +65,64 @@ EOS
   return opts, pdf_filename
 end
 
+def rulings_from_columns(page, area, vertical_rulings)
+  top = area.nil? ? page.top : area.top
+  vertical_rulings.map do |vr|
+    Tabula::Ruling.new(top, vr, 0, page.height)
+  end
+end
+
+def heuristic_to_decide_whether_to_use_spreadsheet_extraction
+  false #TODO
+end
+
 def main
   opts, filename = parse_command_line
 
-  area = opts[:area].nil? ? nil : opts[:area].split(',').map(&:to_f)
-  out = opts[:outfile] == '-' ? $stdout : File.new(opts[:outfile], 'w')
-  extractor = Tabula::Extraction::CharacterExtractor.new(filename, parse_pages_arg(opts[:pages]), opts[:password])
-  extractor.extract.each_with_index do |page, page_index|
-    if opts[:guess]
-      lines = Tabula::Ruling::clean_rulings(Tabula::LSD::detect_lines_in_pdf_page(filename, page_index))
-      page_areas = Tabula::TableGuesser::find_rects_from_lines(lines)
-      page_areas.map!{|rect| rect.dims(:top, :left, :bottom, :right)}
-    else
-      page_areas = [area]
+  area_input = opts[:area].nil? ? nil : opts[:area].split(',').map(&:to_f)
+  vertical_rulings = opts[:columns].nil? ? nil : opts[:columns].split(',').map(&:to_f)
+  out = opts[:outfile] == '-' ? $stdout : File.new(opts[:outfile], 'wb')
+
+  use_spreadsheet_extraction =  if opts[:spreadsheet]
+                                  true
+                                elsif opts[:no_spreadsheet] || opts[:columns] || opts[:area] || opts[:guess]
+                                  false
+                                else
+                                  nil
+                                end
+  extractor = Tabula::Extraction::ObjectExtractor.new(filename, parse_pages_arg(opts[:pages]), opts[:password])
+  extractor.extract.each_with_index do |pdf_page, page_index|
+
+    #do the heuristic here
+    if use_spreadsheet_extraction.nil?
+      use_spreadsheet_extraction = pdf_page.is_tabular?
+      #TODO: tell the user what we're doing, so they can force the other way.
+      STDERR.puts "Using #{use_spreadsheet_extraction ? "spreadsheet": "no_spreadsheet"} extraction method.\n" +
+            "If the output looks wrong, re-run tabula with the #{use_spreadsheet_extraction ? "--no-spreadsheet": "--spreadsheet"} switch." unless opts[:silent]
     end
 
-    page_areas.each do |page_area|
-      if opts[:guess] && opts[:debug]
-        puts (page_index + 1).to_s + ', ' + page_area.to_s
+    if use_spreadsheet_extraction
+      if opts[:debug]
+        pdf_page.spreadsheets.each do |spreadsheet|
+          STDERR.puts "Page #{pdf_page.number(:one_indexed)}: #{spreadsheet.dims(:top, :left, :bottom, :right)}"
+        end
+      end
+      tables = pdf_page.spreadsheets.map(&:rows)
+    else
+      STDERR.puts "Page #{pdf_page.number(:one_indexed)}: #{page_area.to_s}" if opts[:debug]
+      if opts[:guess]
+        page_areas = pdf_page.spreadsheets.map{|rect| pdf_page.get_area(rect.dims(:top, :left, :bottom, :right))}
+      elsif area_input
+        page_areas = [pdf_page.get_area(area_input)]
       else
-        text = page.get_text( page_area )
-        Tabula::Writers.send(opts[:format].to_sym,
-                            Tabula.make_table(text),
-                            out)
+        page_areas = [pdf_page]
       end
-
+      tables = page_areas.map{|page_area| page_area.make_table(vertical_rulings.nil? ? {} : { :vertical_rulings => rulings_from_columns(pdf_page, page_area, vertical_rulings) })}
+    end
+    tables.each do |table|
+      Tabula::Writers.send(opts[:format].to_sym,
+                          table,
+                          out)
     end
   end
   out.close

data/ext/lsd.c

@@ -189,9 +189,9 @@ static void error(char * msg)
     should be related to the cumulated rounding error in the chain of
     computation. Here, as a simplification, a fixed factor is used.
  */
-static int double_equal(double a, double b)
+static int double_equal(float a, float b)
 {
-  double abs_diff,aa,bb,abs_max;
+  float abs_diff,aa,bb,abs_max;
 
   /* trivial case */
   if( a == b ) return TRUE;
@@ -215,7 +215,7 @@ static int double_equal(double a, double b)
 /*----------------------------------------------------------------------------*/
 /** Computes Euclidean distance between point (x1,y1) and point (x2,y2).
  */
-static double dist(double x1, double y1, double x2, double y2)
+static float dist(float x1, float y1, float x2, float y2)
 {
   return sqrt( (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) );
 }
@@ -251,7 +251,7 @@ typedef struct ntuple_list_s
   unsigned int size;
   unsigned int max_size;
   unsigned int dim;
-  double * values;
+  float * values;
 } * ntuple_list;
 
 /*----------------------------------------------------------------------------*/
@@ -286,7 +286,7 @@ static ntuple_list new_ntuple_list(unsigned int dim)
   n_tuple->dim = dim;
 
   /* get memory for tuples */
-  n_tuple->values = (double *) malloc( dim*n_tuple->max_size * sizeof(double) );
+  n_tuple->values = (float *) malloc( dim*n_tuple->max_size * sizeof(float) );
   if( n_tuple->values == NULL ) error("not enough memory.");
 
   return n_tuple;
@@ -305,16 +305,16 @@ static void enlarge_ntuple_list(ntuple_list n_tuple)
   n_tuple->max_size *= 2;
 
   /* realloc memory */
-  n_tuple->values = (double *) realloc( (void *) n_tuple->values,
-                      n_tuple->dim * n_tuple->max_size * sizeof(double) );
+  n_tuple->values = (float *) realloc( (void *) n_tuple->values,
+                      n_tuple->dim * n_tuple->max_size * sizeof(float) );
   if( n_tuple->values == NULL ) error("not enough memory.");
 }
 
 /*----------------------------------------------------------------------------*/
 /** Add a 7-tuple to an n-tuple list.
  */
-static void add_7tuple( ntuple_list out, double v1, double v2, double v3,
-                        double v4, double v5, double v6, double v7 )
+static void add_7tuple( ntuple_list out, float v1, float v2, float v3,
+                        float v4, float v5, float v6, float v7 )
 {
   /* check parameters */
   if( out == NULL ) error("add_7tuple: invalid n-tuple input.");
@@ -479,7 +479,7 @@ static image_int new_image_int_ini( unsigned int xsize, unsigned int ysize,
  */
 typedef struct image_double_s
 {
-  double * data;
+  float * data;
   unsigned int xsize,ysize;
 } * image_double;
 
@@ -507,7 +507,7 @@ static image_double new_image_double(unsigned int xsize, unsigned int ysize)
   /* get memory */
   image = (image_double) malloc( sizeof(struct image_double_s) );
   if( image == NULL ) error("not enough memory.");
-  image->data = (double *) calloc( (size_t) (xsize*ysize), sizeof(double) );
+  image->data = (float *) calloc( (size_t) (xsize*ysize), sizeof(float) );
   if( image->data == NULL ) error("not enough memory.");
 
   /* set image size */
@@ -522,7 +522,7 @@ static image_double new_image_double(unsigned int xsize, unsigned int ysize)
     with the data pointed by 'data'.
  */
 static image_double new_image_double_ptr( unsigned int xsize,
-                                          unsigned int ysize, double * data )
+                                          unsigned int ysize, float * data )
 {
   image_double image;
 
@@ -556,10 +556,10 @@ static image_double new_image_double_ptr( unsigned int xsize,
     in the middle point between values 'kernel->values[0]'
     and 'kernel->values[1]'.
  */
-static void gaussian_kernel(ntuple_list kernel, double sigma, double mean)
+static void gaussian_kernel(ntuple_list kernel, float sigma, float mean)
 {
-  double sum = 0.0;
-  double val;
+  float sum = 0.0;
+  float val;
   unsigned int i;
 
   /* check parameters */
@@ -572,7 +572,7 @@ static void gaussian_kernel(ntuple_list kernel, double sigma, double mean)
   kernel->size = 1;
   for(i=0;i<kernel->dim;i++)
     {
-      val = ( (double) i - mean ) / sigma;
+      val = ( (float) i - mean ) / sigma;
       kernel->values[i] = exp( -0.5 * val * val );
       sum += kernel->values[i];
     }
@@ -619,14 +619,14 @@ static void gaussian_kernel(ntuple_list kernel, double sigma, double mean)
     in the x axis, and then the combined Gaussian kernel and sampling
     in the y axis.
  */
-static image_double gaussian_sampler( image_double in, double scale,
-                                      double sigma_scale )
+static image_double gaussian_sampler( image_double in, float scale,
+                                      float sigma_scale )
 {
   image_double aux,out;
   ntuple_list kernel;
   unsigned int N,M,h,n,x,y,i;
   int xc,yc,j,double_x_size,double_y_size;
-  double sigma,xx,yy,sum,prec;
+  float sigma,xx,yy,sum,prec;
 
   /* check parameters */
   if( in == NULL || in->data == NULL || in->xsize == 0 || in->ysize == 0 )
@@ -636,8 +636,8 @@ static image_double gaussian_sampler( image_double in, double scale,
     error("gaussian_sampler: 'sigma_scale' must be positive.");
 
   /* compute new image size and get memory for images */
-  if( in->xsize * scale > (double) UINT_MAX ||
-      in->ysize * scale > (double) UINT_MAX )
+  if( in->xsize * scale > (float) UINT_MAX ||
+      in->ysize * scale > (float) UINT_MAX )
     error("gaussian_sampler: the output image size exceeds the handled size.");
   N = (unsigned int) ceil( in->xsize * scale );
   M = (unsigned int) ceil( in->ysize * scale );
@@ -671,11 +671,11 @@ static image_double gaussian_sampler( image_double in, double scale,
          xx  is the corresponding x-value in the original size image.
          xc  is the integer value, the pixel coordinate of xx.
        */
-      xx = (double) x / scale;
+      xx = (float) x / scale;
       /* coordinate (0.0,0.0) is in the center of pixel (0,0),
          so the pixel with xc=0 get the values of xx from -0.5 to 0.5 */
       xc = (int) floor( xx + 0.5 );
-      gaussian_kernel( kernel, sigma, (double) h + xx - (double) xc );
+      gaussian_kernel( kernel, sigma, (float) h + xx - (float) xc );
       /* the kernel must be computed for each x because the fine
          offset xx-xc is different in each case */
 
@@ -705,11 +705,11 @@ static image_double gaussian_sampler( image_double in, double scale,
          yy  is the corresponding x-value in the original size image.
          yc  is the integer value, the pixel coordinate of xx.
        */
-      yy = (double) y / scale;
+      yy = (float) y / scale;
       /* coordinate (0.0,0.0) is in the center of pixel (0,0),
          so the pixel with yc=0 get the values of yy from -0.5 to 0.5 */
       yc = (int) floor( yy + 0.5 );
-      gaussian_kernel( kernel, sigma, (double) h + yy - (double) yc );
+      gaussian_kernel( kernel, sigma, (float) h + yy - (float) yc );
       /* the kernel must be computed for each y because the fine
          offset yy-yc is different in each case */
 
@@ -760,13 +760,13 @@ static image_double gaussian_sampler( image_double in, double scale,
     - a pointer 'mem_p' to the memory used by 'list_p' to be able to
       free the memory when it is not used anymore.
  */
-static image_double ll_angle( image_double in, double threshold,
+static image_double ll_angle( image_double in, float threshold,
                               struct coorlist ** list_p, void ** mem_p,
                               image_double * modgrad, unsigned int n_bins )
 {
   image_double g;
   unsigned int n,p,x,y,adr,i;
-  double com1,com2,gx,gy,norm,norm2;
+  float com1,com2,gx,gy,norm,norm2;
   /* the rest of the variables are used for pseudo-ordering
      the gradient magnitude values */
   int list_count = 0;
@@ -775,7 +775,7 @@ static image_double ll_angle( image_double in, double threshold,
   struct coorlist ** range_l_e; /* array of pointers to end of bin list */
   struct coorlist * start;
   struct coorlist * end;
-  double max_grad = 0.0;
+  float max_grad = 0.0;
 
   /* check parameters */
   if( in == NULL || in->data == NULL || in->xsize == 0 || in->ysize == 0 )
@@ -858,7 +858,7 @@ static image_double ll_angle( image_double in, double threshold,
         norm = (*modgrad)->data[y*p+x];
 
         /* store the point in the right bin according to its norm */
-        i = (unsigned int) (norm * (double) n_bins / max_grad);
+        i = (unsigned int) (norm * (float) n_bins / max_grad);
         if( i >= n_bins ) i = n_bins-1;
         if( range_l_e[i] == NULL )
           range_l_s[i] = range_l_e[i] = list+list_count++;
@@ -902,10 +902,10 @@ static image_double ll_angle( image_double in, double threshold,
 /*----------------------------------------------------------------------------*/
 /** Is point (x,y) aligned to angle theta, up to precision 'prec'?
  */
-static int isaligned( int x, int y, image_double angles, double theta,
-                      double prec )
+static int isaligned( int x, int y, image_double angles, float theta,
+                      float prec )
 {
-  double a;
+  float a;
 
   /* check parameters */
   if( angles == NULL || angles->data == NULL )
@@ -940,7 +940,7 @@ static int isaligned( int x, int y, image_double angles, double theta,
 /*----------------------------------------------------------------------------*/
 /** Absolute value angle difference.
  */
-static double angle_diff(double a, double b)
+static double angle_diff(float a, float b)
 {
   a -= b;
   while( a <= -M_PI ) a += M_2__PI;
@@ -952,7 +952,7 @@ static double angle_diff(double a, double b)
 /*----------------------------------------------------------------------------*/
 /** Signed angle difference.
  */
-static double angle_diff_signed(double a, double b)
+static double angle_diff_signed(float a, float b)
 {
   a -= b;
   while( a <= -M_PI ) a += M_2__PI;
@@ -989,19 +989,19 @@ static double angle_diff_signed(double a, double b)
       q5 = 83.8676043424,
       q6 = 2.50662827511.
  */
-static double log_gamma_lanczos(double x)
+static double log_gamma_lanczos(float x)
 {
-  static double q[7] = { 75122.6331530, 80916.6278952, 36308.2951477,
+  static float q[7] = { 75122.6331530, 80916.6278952, 36308.2951477,
                          8687.24529705, 1168.92649479, 83.8676043424,
                          2.50662827511 };
-  double a = (x+0.5) * log(x+5.5) - (x+5.5);
-  double b = 0.0;
+  float a = (x+0.5) * log(x+5.5) - (x+5.5);
+  float b = 0.0;
   int n;
 
   for(n=0;n<7;n++)
     {
-      a -= log( x + (double) n );
-      b += q[n] * pow( x, (double) n );
+      a -= log( x + (float) n );
+      b += q[n] * pow( x, (float) n );
     }
   return a + log(b);
 }
@@ -1023,7 +1023,7 @@ static double log_gamma_lanczos(double x)
     @f]
     This formula is a good approximation when x > 15.
  */
-static double log_gamma_windschitl(double x)
+static double log_gamma_windschitl(float x)
 {
   return 0.918938533204673 + (x-0.5)*log(x) - x
          + 0.5*x*log( x*sinh(1/x) + 1/(810.0*pow(x,6.0)) );
@@ -1083,11 +1083,11 @@ static double log_gamma_windschitl(double x)
     of the terms are neglected based on a bound to the error obtained
     (an error of 10% in the result is accepted).
  */
-static double nfa(int n, int k, double p, double logNT)
+static double nfa(int n, int k, float p, float logNT)
 {
-  static double inv[TABSIZE];   /* table to keep computed inverse values */
-  double tolerance = 0.1;       /* an error of 10% in the result is accepted */
-  double log1term,term,bin_term,mult_term,bin_tail,err,p_term;
+  static float inv[TABSIZE];   /* table to keep computed inverse values */
+  float tolerance = 0.1;       /* an error of 10% in the result is accepted */
+  float log1term,term,bin_term,mult_term,bin_tail,err,p_term;
   int i;
 
   /* check parameters */
@@ -1096,7 +1096,7 @@ static double nfa(int n, int k, double p, double logNT)
 
   /* trivial cases */
   if( n==0 || k==0 ) return -logNT;
-  if( n==k ) return -logNT - (double) n * log10(p);
+  if( n==k ) return -logNT - (float) n * log10(p);
 
   /* probability term */
   p_term = p / (1.0-p);
@@ -1109,15 +1109,15 @@ static double nfa(int n, int k, double p, double logNT)
        bincoef(n,k) = gamma(n+1) / ( gamma(k+1) * gamma(n-k+1) ).
      We use this to compute the first term. Actually the log of it.
    */
-  log1term = log_gamma( (double) n + 1.0 ) - log_gamma( (double) k + 1.0 )
-           - log_gamma( (double) (n-k) + 1.0 )
-           + (double) k * log(p) + (double) (n-k) * log(1.0-p);
+  log1term = log_gamma( (float) n + 1.0 ) - log_gamma( (float) k + 1.0 )
+           - log_gamma( (float) (n-k) + 1.0 )
+           + (float) k * log(p) + (float) (n-k) * log(1.0-p);
   term = exp(log1term);
 
   /* in some cases no more computations are needed */
   if( double_equal(term,0.0) )              /* the first term is almost zero */
     {
-      if( (double) k > (double) n * p )     /* at begin or end of the tail?  */
+      if( (float) k > (float) n * p )     /* at begin or end of the tail?  */
         return -log1term / M_LN10 - logNT;  /* end: use just the first term  */
       else
         return -logNT;                      /* begin: the tail is roughly 1  */
@@ -1140,9 +1140,9 @@ static double nfa(int n, int k, double p, double logNT)
          because divisions are expensive.
          p/(1-p) is computed only once and stored in 'p_term'.
        */
-      bin_term = (double) (n-i+1) * ( i<TABSIZE ?
-                   ( inv[i]!=0.0 ? inv[i] : ( inv[i] = 1.0 / (double) i ) ) :
-                   1.0 / (double) i );
+      bin_term = (float) (n-i+1) * ( i<TABSIZE ?
+                   ( inv[i]!=0.0 ? inv[i] : ( inv[i] = 1.0 / (float) i ) ) :
+                   1.0 / (float) i );
 
       mult_term = bin_term * p_term;
       term *= mult_term;
@@ -1153,7 +1153,7 @@ static double nfa(int n, int k, double p, double logNT)
              Then, the error on the binomial tail when truncated at
              the i term can be bounded by a geometric series of form
              term_i * sum mult_term_i^j.                            */
-          err = term * ( ( 1.0 - pow( mult_term, (double) (n-i+1) ) ) /
+          err = term * ( ( 1.0 - pow( mult_term, (float) (n-i+1) ) ) /
                          (1.0-mult_term) - 1.0 );
 
           /* One wants an error at most of tolerance*final_result, or:
@@ -1180,13 +1180,13 @@ static double nfa(int n, int k, double p, double logNT)
  */
 struct rect
 {
-  double x1,y1,x2,y2;  /* first and second point of the line segment */
-  double width;        /* rectangle width */
-  double x,y;          /* center of the rectangle */
-  double theta;        /* angle */
-  double dx,dy;        /* (dx,dy) is vector oriented as the line segment */
-  double prec;         /* tolerance angle */
-  double p;            /* probability of a point with angle within 'prec' */
+  float x1,y1,x2,y2;  /* first and second point of the line segment */
+  float width;        /* rectangle width */
+  float x,y;          /* center of the rectangle */
+  float theta;        /* angle */
+  float dx,dy;        /* (dx,dy) is vector oriented as the line segment */
+  float prec;         /* tolerance angle */
+  float p;            /* probability of a point with angle within 'prec' */
 };
 
 /*----------------------------------------------------------------------------*/
@@ -1270,9 +1270,9 @@ static void rect_copy(struct rect * in, struct rect * out)
  */
 typedef struct
 {
-  double vx[4];  /* rectangle's corner X coordinates in circular order */
-  double vy[4];  /* rectangle's corner Y coordinates in circular order */
-  double ys,ye;  /* start and end Y values of current 'column' */
+  float vx[4];  /* rectangle's corner X coordinates in circular order */
+  float vy[4];  /* rectangle's corner Y coordinates in circular order */
+  float ys,ye;  /* start and end Y values of current 'column' */
   int x,y;       /* coordinates of currently explored pixel */
 } rect_iter;
 
@@ -1286,7 +1286,7 @@ typedef struct
     - x1 <= x
     - x  <= x2
  */
-static double inter_low(double x, double x1, double y1, double x2, double y2)
+static double inter_low(float x, float x1, float y1, float x2, float y2)
 {
   /* check parameters */
   if( x1 > x2 || x < x1 || x > x2 )
@@ -1308,7 +1308,7 @@ static double inter_low(double x, double x1, double y1, double x2, double y2)
     - x1 <= x
     - x  <= x2
  */
-static double inter_hi(double x, double x1, double y1, double x2, double y2)
+static double inter_hi(float x, float x1, float y1, float x2, float y2)
 {
   /* check parameters */
   if( x1 > x2 || x < x1 || x > x2 )
@@ -1342,7 +1342,7 @@ static int ri_end(rect_iter * i)
   /* if the current x value is larger than the largest
      x value in the rectangle (vx[2]), we know the full
      exploration of the rectangle is finished. */
-  return (double)(i->x) > i->vx[2];
+  return (float)(i->x) > i->vx[2];
 }
 
 /*----------------------------------------------------------------------------*/
@@ -1362,7 +1362,7 @@ static void ri_inc(rect_iter * i)
   /* if the end of the current 'column' is reached,
      and it is not the end of exploration,
      advance to the next 'column' */
-  while( (double) (i->y) > i->ye && !ri_end(i) )
+  while( (float) (i->y) > i->ye && !ri_end(i) )
     {
       /* increase x, next 'column' */
       i->x++;
@@ -1385,10 +1385,10 @@ static void ri_inc(rect_iter * i)
          or last 'columns') then we pick the lower value of the side
          by using 'inter_low'.
        */
-      if( (double) i->x < i->vx[3] )
-        i->ys = inter_low((double)i->x,i->vx[0],i->vy[0],i->vx[3],i->vy[3]);
+      if( (float) i->x < i->vx[3] )
+        i->ys = inter_low((float)i->x,i->vx[0],i->vy[0],i->vx[3],i->vy[3]);
       else
-        i->ys = inter_low((double)i->x,i->vx[3],i->vy[3],i->vx[2],i->vy[2]);
+        i->ys = inter_low((float)i->x,i->vx[3],i->vy[3],i->vx[2],i->vy[2]);
 
       /* update upper y limit (end) for the new 'column'.
 
@@ -1405,10 +1405,10 @@ static void ri_inc(rect_iter * i)
          or last 'columns') then we pick the lower value of the side
          by using 'inter_low'.
        */
-      if( (double)i->x < i->vx[1] )
-        i->ye = inter_hi((double)i->x,i->vx[0],i->vy[0],i->vx[1],i->vy[1]);
+      if( (float)i->x < i->vx[1] )
+        i->ye = inter_hi((float)i->x,i->vx[0],i->vy[0],i->vx[1],i->vy[1]);
       else
-        i->ye = inter_hi((double)i->x,i->vx[1],i->vy[1],i->vx[2],i->vy[2]);
+        i->ye = inter_hi((float)i->x,i->vx[1],i->vy[1],i->vx[2],i->vy[2]);
 
       /* new y */
       i->y = (int) ceil(i->ys);
@@ -1422,7 +1422,7 @@ static void ri_inc(rect_iter * i)
  */
 static rect_iter * ri_ini(struct rect * r)
 {
-  double vx[4],vy[4];
+  float vx[4],vy[4];
   int n,offset;
   rect_iter * i;
 
@@ -1491,7 +1491,7 @@ static rect_iter * ri_ini(struct rect * r)
 /*----------------------------------------------------------------------------*/
 /** Compute a rectangle's NFA value.
  */
-static double rect_nfa(struct rect * rec, image_double angles, double logNT)
+static float rect_nfa(struct rect * rec, image_double angles, float logNT)
 {
   rect_iter * i;
   int pts = 0;
@@ -1577,13 +1577,13 @@ static double rect_nfa(struct rect * rec, image_double angles, double logNT)
     When |Ixx| > |Iyy| we use the first, otherwise the second (just to
     get better numeric precision).
  */
-static double get_theta( struct point * reg, int reg_size, double x, double y,
-                         image_double modgrad, double reg_angle, double prec )
+static float get_theta( struct point * reg, int reg_size, float x, float y,
+                         image_double modgrad, float reg_angle, float prec )
 {
-  double lambda,theta,weight;
-  double Ixx = 0.0;
-  double Iyy = 0.0;
-  double Ixy = 0.0;
+  float lambda,theta,weight;
+  float Ixx = 0.0;
+  float Iyy = 0.0;
+  float Ixy = 0.0;
   int i;
 
   /* check parameters */
@@ -1597,9 +1597,9 @@ static double get_theta( struct point * reg, int reg_size, double x, double y,
   for(i=0; i<reg_size; i++)
     {
       weight = modgrad->data[ reg[i].x + reg[i].y * modgrad->xsize ];
-      Ixx += ( (double) reg[i].y - y ) * ( (double) reg[i].y - y ) * weight;
-      Iyy += ( (double) reg[i].x - x ) * ( (double) reg[i].x - x ) * weight;
-      Ixy -= ( (double) reg[i].x - x ) * ( (double) reg[i].y - y ) * weight;
+      Ixx += ( (float) reg[i].y - y ) * ( (float) reg[i].y - y ) * weight;
+      Iyy += ( (float) reg[i].x - x ) * ( (float) reg[i].x - x ) * weight;
+      Ixy -= ( (float) reg[i].x - x ) * ( (float) reg[i].y - y ) * weight;
     }
   if( double_equal(Ixx,0.0) && double_equal(Iyy,0.0) && double_equal(Ixy,0.0) )
     error("get_theta: null inertia matrix.");
@@ -1621,10 +1621,10 @@ static double get_theta( struct point * reg, int reg_size, double x, double y,
 /** Computes a rectangle that covers a region of points.
  */
 static void region2rect( struct point * reg, int reg_size,
-                         image_double modgrad, double reg_angle,
-                         double prec, double p, struct rect * rec )
+                         image_double modgrad, float reg_angle,
+                         float prec, float p, struct rect * rec )
 {
-  double x,y,dx,dy,l,w,theta,weight,sum,l_min,l_max,w_min,w_max;
+  float x,y,dx,dy,l,w,theta,weight,sum,l_min,l_max,w_min,w_max;
   int i;
 
   /* check parameters */
@@ -1648,8 +1648,8 @@ static void region2rect( struct point * reg, int reg_size,
   for(i=0; i<reg_size; i++)
     {
       weight = modgrad->data[ reg[i].x + reg[i].y * modgrad->xsize ];
-      x += (double) reg[i].x * weight;
-      y += (double) reg[i].y * weight;
+      x += (float) reg[i].x * weight;
+      y += (float) reg[i].y * weight;
       sum += weight;
     }
   if( sum <= 0.0 ) error("region2rect: weights sum equal to zero.");
@@ -1676,8 +1676,8 @@ static void region2rect( struct point * reg, int reg_size,
   l_min = l_max = w_min = w_max = 0.0;
   for(i=0; i<reg_size; i++)
     {
-      l =  ( (double) reg[i].x - x) * dx + ( (double) reg[i].y - y) * dy;
-      w = -( (double) reg[i].x - x) * dy + ( (double) reg[i].y - y) * dx;
+      l =  ( (float) reg[i].x - x) * dx + ( (float) reg[i].y - y) * dy;
+      w = -( (float) reg[i].x - x) * dy + ( (float) reg[i].y - y) * dx;
 
       if( l > l_max ) l_max = l;
       if( l < l_min ) l_min = l;
@@ -1714,10 +1714,10 @@ static void region2rect( struct point * reg, int reg_size,
     tolerance 'prec', starting at point (x,y).
  */
 static void region_grow( int x, int y, image_double angles, struct point * reg,
-                         int * reg_size, double * reg_angle, image_char used,
-                         double prec )
+                         int * reg_size, float * reg_angle, image_char used,
+                         float prec )
 {
-  double sumdx,sumdy;
+  float sumdx,sumdy;
   int xx,yy,i;
 
   /* check parameters */
@@ -1765,13 +1765,13 @@ static void region_grow( int x, int y, image_double angles, struct point * reg,
 /** Try some rectangles variations to improve NFA value. Only if the
     rectangle is not meaningful (i.e., log_nfa <= log_eps).
  */
-static double rect_improve( struct rect * rec, image_double angles,
-                            double logNT, double log_eps )
+static float rect_improve( struct rect * rec, image_double angles,
+                            float logNT, float log_eps )
 {
   struct rect r;
-  double log_nfa,log_nfa_new;
-  double delta = 0.5;
-  double delta_2 = delta / 2.0;
+  float log_nfa,log_nfa_new;
+  float delta = 0.5;
+  float delta_2 = delta / 2.0;
   int n;
 
   log_nfa = rect_nfa(rec,angles,logNT);
@@ -1879,12 +1879,12 @@ static double rect_improve( struct rect * rec, image_double angles,
     density of region points or to discard the region if too small.
  */
 static int reduce_region_radius( struct point * reg, int * reg_size,
-                                 image_double modgrad, double reg_angle,
-                                 double prec, double p, struct rect * rec,
+                                 image_double modgrad, float reg_angle,
+                                 float prec, float p, struct rect * rec,
                                  image_char used, image_double angles,
-                                 double density_th )
+                                 float density_th )
 {
-  double density,rad1,rad2,rad,xc,yc;
+  float density,rad1,rad2,rad,xc,yc;
   int i;
 
   /* check parameters */
@@ -1899,15 +1899,15 @@ static int reduce_region_radius( struct point * reg, int * reg_size,
     error("reduce_region_radius: invalid image 'angles'.");
 
   /* compute region points density */
-  density = (double) *reg_size /
+  density = (float) *reg_size /
                          ( dist(rec->x1,rec->y1,rec->x2,rec->y2) * rec->width );
 
   /* if the density criterion is satisfied there is nothing to do */
   if( density >= density_th ) return TRUE;
 
   /* compute region's radius */
-  xc = (double) reg[0].x;
-  yc = (double) reg[0].y;
+  xc = (float) reg[0].x;
+  yc = (float) reg[0].y;
   rad1 = dist( xc, yc, rec->x1, rec->y1 );
   rad2 = dist( xc, yc, rec->x2, rec->y2 );
   rad = rad1 > rad2 ? rad1 : rad2;
@@ -1919,7 +1919,7 @@ static int reduce_region_radius( struct point * reg, int * reg_size,
 
       /* remove points from the region and update 'used' map */
       for(i=0; i<*reg_size; i++)
-        if( dist( xc, yc, (double) reg[i].x, (double) reg[i].y ) > rad )
+        if( dist( xc, yc, (float) reg[i].x, (float) reg[i].y ) > rad )
           {
             /* point not kept, mark it as NOTUSED */
             used->data[ reg[i].x + reg[i].y * used->xsize ] = NOTUSED;
@@ -1938,7 +1938,7 @@ static int reduce_region_radius( struct point * reg, int * reg_size,
       region2rect(reg,*reg_size,modgrad,reg_angle,prec,p,rec);
 
       /* re-compute region points density */
-      density = (double) *reg_size /
+      density = (float) *reg_size /
                          ( dist(rec->x1,rec->y1,rec->x2,rec->y2) * rec->width );
     }
 
@@ -1957,10 +1957,10 @@ static int reduce_region_radius( struct point * reg, int * reg_size,
     'reduce_region_radius' is called to try to satisfy this condition.
  */
 static int refine( struct point * reg, int * reg_size, image_double modgrad,
-                   double reg_angle, double prec, double p, struct rect * rec,
-                   image_char used, image_double angles, double density_th )
+                   float reg_angle, float prec, float p, struct rect * rec,
+                   image_char used, image_double angles, float density_th )
 {
-  double angle,ang_d,mean_angle,tau,density,xc,yc,ang_c,sum,s_sum;
+  float angle,ang_d,mean_angle,tau,density,xc,yc,ang_c,sum,s_sum;
   int i,n;
 
   /* check parameters */
@@ -1974,7 +1974,7 @@ static int refine( struct point * reg, int * reg_size, image_double modgrad,
     error("refine: invalid image 'angles'.");
 
   /* compute region points density */
-  density = (double) *reg_size /
+  density = (float) *reg_size /
                          ( dist(rec->x1,rec->y1,rec->x2,rec->y2) * rec->width );
 
   /* if the density criterion is satisfied there is nothing to do */
@@ -1983,15 +1983,15 @@ static int refine( struct point * reg, int * reg_size, image_double modgrad,
   /*------ First try: reduce angle tolerance ------*/
 
   /* compute the new mean angle and tolerance */
-  xc = (double) reg[0].x;
-  yc = (double) reg[0].y;
+  xc = (float) reg[0].x;
+  yc = (float) reg[0].y;
   ang_c = angles->data[ reg[0].x + reg[0].y * angles->xsize ];
   sum = s_sum = 0.0;
   n = 0;
   for(i=0; i<*reg_size; i++)
     {
       used->data[ reg[i].x + reg[i].y * used->xsize ] = NOTUSED;
-      if( dist( xc, yc, (double) reg[i].x, (double) reg[i].y ) < rec->width )
+      if( dist( xc, yc, (float) reg[i].x, (float) reg[i].y ) < rec->width )
         {
           angle = angles->data[ reg[i].x + reg[i].y * angles->xsize ];
           ang_d = angle_diff_signed(angle,ang_c);
@@ -2000,8 +2000,8 @@ static int refine( struct point * reg, int * reg_size, image_double modgrad,
           ++n;
         }
     }
-  mean_angle = sum / (double) n;
-  tau = 2.0 * sqrt( (s_sum - 2.0 * mean_angle * sum) / (double) n
+  mean_angle = sum / (float) n;
+  tau = 2.0 * sqrt( (s_sum - 2.0 * mean_angle * sum) / (float) n
                          + mean_angle*mean_angle ); /* 2 * standard deviation */
 
   /* find a new region from the same starting point and new angle tolerance */
@@ -2014,7 +2014,7 @@ static int refine( struct point * reg, int * reg_size, image_double modgrad,
   region2rect(reg,*reg_size,modgrad,reg_angle,prec,p,rec);
 
   /* re-compute region points density */
-  density = (double) *reg_size /
+  density = (float) *reg_size /
                       ( dist(rec->x1,rec->y1,rec->x2,rec->y2) * rec->width );
 
   /*------ Second try: reduce region radius ------*/
@@ -2034,16 +2034,16 @@ static int refine( struct point * reg, int * reg_size, image_double modgrad,
 /*----------------------------------------------------------------------------*/
 /** LSD full interface.
  */
-double * LineSegmentDetection( int * n_out,
-                               double * img, int X, int Y,
-                               double scale, double sigma_scale, double quant,
-                               double ang_th, double log_eps, double density_th,
+float * LineSegmentDetection( int * n_out,
+                               float * img, int X, int Y,
+                               float scale, float sigma_scale, float quant,
+                               float ang_th, float log_eps, float density_th,
                                int n_bins,
                                int ** reg_img, int * reg_x, int * reg_y )
 {
   image_double image;
   ntuple_list out = new_ntuple_list(7);
-  double * return_value;
+  float * return_value;
   image_double scaled_image,angles,modgrad;
   image_char used;
   image_int region = NULL;
@@ -2053,7 +2053,7 @@ double * LineSegmentDetection( int * n_out,
   struct point * reg;
   int reg_size,min_reg_size,i;
   unsigned int xsize,ysize;
-  double rho,reg_angle,prec,p,log_nfa,logNT;
+  float rho,reg_angle,prec,p,log_nfa,logNT;
   int ls_count = 0;                   /* line segments are numbered 1,2,3,... */
 
 
@@ -2103,7 +2103,7 @@ double * LineSegmentDetection( int * n_out,
      whose logarithm value is
        log10(11) + 5/2 * (log10(X) + log10(Y)).
   */
-  logNT = 5.0 * ( log10( (double) xsize ) + log10( (double) ysize ) ) / 2.0
+  logNT = 5.0 * ( log10( (float) xsize ) + log10( (float) ysize ) ) / 2.0
           + log10(11.0);
   min_reg_size = (int) (-logNT/log10(p)); /* minimal number of points in region
                                              that can give a meaningful event */
@@ -2221,18 +2221,18 @@ double * LineSegmentDetection( int * n_out,
 /*----------------------------------------------------------------------------*/
 /** LSD Simple Interface with Scale and Region output.
  */
-double * lsd_scale_region( int * n_out,
-                           double * img, int X, int Y, double scale,
+float * lsd_scale_region( int * n_out,
+                           float * img, int X, int Y, float scale,
                            int ** reg_img, int * reg_x, int * reg_y )
 {
   /* LSD parameters */
-  double sigma_scale = 0.6; /* Sigma for Gaussian filter is computed as
+  float sigma_scale = 0.6; /* Sigma for Gaussian filter is computed as
                                 sigma = sigma_scale/scale.                    */
-  double quant = 2.0;       /* Bound to the quantization error on the
+  float quant = 2.0;       /* Bound to the quantization error on the
                                 gradient norm.                                */
-  double ang_th = 22.5;     /* Gradient angle tolerance in degrees.           */
-  double log_eps = 0.0;     /* Detection threshold: -log10(NFA) > log_eps     */
-  double density_th = 0.7;  /* Minimal density of region points in rectangle. */
+  float ang_th = 22.5;     /* Gradient angle tolerance in degrees.           */
+  float log_eps = 0.0;     /* Detection threshold: -log10(NFA) > log_eps     */
+  float density_th = 0.7;  /* Minimal density of region points in rectangle. */
   int n_bins = 1024;        /* Number of bins in pseudo-ordering of gradient
                                modulus.                                       */
 
@@ -2244,7 +2244,7 @@ double * lsd_scale_region( int * n_out,
 /*----------------------------------------------------------------------------*/
 /** LSD Simple Interface with Scale.
  */
-double * lsd_scale(int * n_out, double * img, int X, int Y, double scale)
+float * lsd_scale(int * n_out, float * img, int X, int Y, float scale)
 {
   return lsd_scale_region(n_out,img,X,Y,scale,NULL,NULL,NULL);
 }
@@ -2252,10 +2252,10 @@ double * lsd_scale(int * n_out, double * img, int X, int Y, double scale)
 /*----------------------------------------------------------------------------*/
 /** LSD Simple Interface.
  */
-double * lsd(int * n_out, double * img, int X, int Y)
+float * lsd(int * n_out, float * img, int X, int Y)
 {
   /* LSD parameters */
-  double scale = 0.8;       /* Scale the image by Gaussian filter to 'scale'. */
+  float scale = 0.8;       /* Scale the image by Gaussian filter to 'scale'. */
 
   return lsd_scale(n_out,img,X,Y,scale);
 
@@ -2265,6 +2265,6 @@ double * lsd(int * n_out, double * img, int X, int Y)
 
 /***** added by manuel aristaran ****/
 
-void free_values(double * p) {
+void free_values(float * p) {
   free((void *) p);
 }