contrek 1.1.4 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b2690fa75c9a6671f9c8ea91522d3adaf8600bfc0739dad4c8eb4a14b80d97e
-  data.tar.gz: 38db9719cc44356ec32d33031e877edda131a970ec0fb5e385f9c31e19699858
+  metadata.gz: 1646e5fe0beaeafefcf2d60230a12ead391c9d75c771807332de7e06128198e4
+  data.tar.gz: a42d904e10ca321d8091263af986193332ac1507cdb2155e92373cf222faa864
 SHA512:
-  metadata.gz: 4827a05d797400b0245c8225274dc070870e83186d51da4b4f16bb8368359597967012b65cedbff39f808fa9d1eafad5e3012e144f10afb801d564a2ff916dca
-  data.tar.gz: 690435e9531d0c8c47c703e41c4719333b91edbe60232a5183c30e21a2822c06b827498b49afbda4785cff404e3abdaf776f0a0b4aec9c9b58a0a9fbf29c8844
+  metadata.gz: 32495e09d3c742d1c8a1011df2c08a204a510766a0bc4fa5bf9f647fcba5c15fe691fc5ef7207f1caeb9c9caa0ff041948cc12f6e042261dd1b1d49e69c8f430
+  data.tar.gz: 28a0e9ff0cc67cfbe7f56f73ae660d68a1ca82243ac656a67cff4c9aefff506eaf0230edc7973de9d900cb1f63e4946f9eed8c39cd9a04de01861dbcf04cb6cf

data/CHANGELOG.md

@@ -58,3 +58,13 @@ All notable changes to this project will be documented in this file.
 ### Changed
 - Fixed an infinite loop bug in multithreading during inner sequence joining in Omnidirectional mode.
 - Optimized C++ and Ruby algorithms for initial spatial tangential sequence determination.
+
+## [1.1.5] - 2026-03-08
+### Changed
+- **RawBitmap Integration (Ruby/C++):** Introduced a native buffer class for direct contour extraction, bypassing PNG encoding to significantly reduce latency and memory overhead.
+- **Tiled Polygon Merger:** Added a spatial merger for `Finder` outputs to stitch polygons from discrete sub-areas (requiring only a 1px overlap). This multi-phase workflow supports coordinate translation and eliminates monolithic buffer requirements, optimizing the peak memory footprint.
+
+## [1.1.6] - 2026-03-21
+### Changed
+- Added strict_bounds tracing mode: enables more accurate shape tracing by strictly adhering to pixel boundaries.
+- Topological Consistency Fixes: improved the Topologically Consistent Merging algorithm to support progressive polygon tracing during sequential data streaming.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    contrek (1.1.4)
+    contrek (1.1.5)
       chunky_png (~> 1.4)
       concurrent-ruby (~> 1.3.5)
       rice (= 4.5.0)

data/README.md

@@ -1,14 +1,53 @@
 # Contrek
-Contrek is a Ruby gem powered by a <u>standalone C++17 core library</u> for fast contour tracing and edge detection in PNG images. It employs a **topological approach** to extract polygonal contours, representing shapes as a connected graph of shared endpoints. This ensures perfect adjacency and structural integrity for shape analysis and raster-to-vector workflows, such as PNG to SVG conversion, managed via libspng (0.7.4) with multithreading support.
+Contrek is a Ruby gem powered by a <u>standalone C++17 core library</u> for fast contour tracing and edge detection in PNG images and raw memory streams. It employs a **topological approach** to extract polygonal contours, representing shapes as a connected graph of shared endpoints. This ensures perfect adjacency and structural integrity for shape analysis and raster-to-vector workflows, such as PNG to SVG conversion, managed via libspng (0.7.4) with multithreading support.
 
 
 ## About Contrek library
 
-Contrek (**con**tour **trek**king) simply scans your png bitmap and returns shape contour as close polygonal lines, both for the external and internal sides. It can compute the nesting level of the polygons found with a tree structure. It supports various levels and modes of compression and approximation of the found coordinates. It is capable of multithreaded processing, splitting the image into vertical strips and recombining the coordinates in pairs.
+Contrek (**con**tour **trek**king) simply scans your png/raw bitmap and returns shape contour as close polygonal lines, both for the external and internal sides. It can compute the nesting level of the polygons found with a tree structure. It supports various levels and modes of compression and approximation of the found coordinates. It is capable of multithreaded processing, splitting the image into vertical strips and recombining the coordinates in pairs.
 
 In the following image all the non-white pixels have been examined and the result is the red polygon for the outer contour and the green one for the inner one
 ![alt text](contrek.png "Contour tracing")
 
+## 🚀 Why Contrek?
+
+Contrek is a high-performance vectorization engine designed for massive datasets where memory efficiency and multi-core utilization are critical. Unlike traditional sequential contour tracers, Contrek is built on a **Stripe-Merging Architecture** that allows it to process images in independent segments and reconstruct the resulting polygons with perfect topological integrity.
+
+### 1. Parallel Processing Power
+Contrek is designed to saturate all available CPU cores. By partitioning a single image into stripes, it can assign each segment to a different thread.
+* **The Result:** On multi-core systems, Contrek achieves unmatched extraction speeds by parallelizing the workload.
+* **Scalability:** Performance scales directly with your hardware, making it the ideal choice for high-throughput processing servers.
+
+### 2. Streamed Memory Management
+Standard vectorization requires loading entire high-resolution images into RAM, which often leads to memory saturation.
+* **The Solution:** Contrek enables **streamed processing** (see the C++ example in the repo). You can define a specific stripe height (buffer) and process the image incrementally, consuming only the memory allocated for that buffer.
+* **The Benefit:** Vectorize massive, gigapixel-scale images or raw datasets directly from memory buffers. This allows for high-performance processing even on systems with limited memory that would otherwise fail.
+
+### 3. Intelligent "Stitching" Technology
+The core strength of Contrek is its **Topologically Consistent Merging** algorithm, which maintains a deep understanding of polygon connectivity across stripe boundaries.
+* Whether you are optimizing for **speed** (parallel cores) or **memory** (sequential streaming), the output is always a seamless, continuous set of vector data, free from gaps or duplicates at the seams.
+
+<table>
+  <tr>
+    <td><img src="docs/images/stripes/whole_0.png" alt="Contour tracing stripe 0" width="50%"></td>
+    <td rowspan="4" align="center">
+      <img src="docs/images/stripes/whole.png" alt="Contour tracing stripe 0" width="50%">
+    </td>
+  </tr>
+  <tr>
+    <td><img src="docs/images/stripes/whole_256.png" alt="Contour tracing stripe 0" width="50%"></td>
+  </tr>
+  <tr>
+    <td><img src="docs/images/stripes/whole_512.png" alt="Contour tracing stripe 0" width="50%"></td>
+  </tr>
+  <tr>
+    <td><img src="docs/images/stripes/whole_768.png" alt="Contour tracing stripe 0" width="50%"></td>
+  </tr>
+  <tr><td colspan="2"><em><b>Left:</b> The image is split into 4 independent memory buffers (stripes).
+  <br><b>Right:</b> Contrek ensures <b>perfect topological continuity</b> during merging.</em>
+    <br><span style="color: #d32f2f;">■</span> <b>Red:</b> Outer contours |
+    <span style="color: #2e7d32;">■</span> <b>Dark Green:</b> Inner zones</td></tr>
+</table>
 
 ## Prerequisites
 
@@ -86,6 +125,24 @@ You can also read base64 png images
 png_bitmap = CPPRemotePngBitMap.new("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+P+/HgAFhAJ/wlseKgAAAABJRU5ErkJggg==")
 ```
 
+You can process from a raw stream
+```ruby
+  raw_bitmap = CPPRawBitMap.new
+  # set 20 as width, 30 as height, 4 as bytes per pixel and clears the content (true)
+  raw_bitmap.define(20,30,4,true)
+  # draws a polygon
+  4.upto(5) do |y|
+    5.upto(8) do |x|
+      raw_bitmap.draw_pixel(x, y, 1, 0, 0, 0);
+    end
+  end
+  not_matcher = CPPRGBNotMatcher.new(raw_bitmap.rgb_value_at(0, 0))
+  result = CPPPolygonFinder.new(raw_bitmap, not_matcher, nil,{compress: {uniq: true, linear: true}}).process_info
+  puts result.points.inspect
+  =>
+  [{:outer=>[{:x=>5, :y=>4}, {:x=>5, :y=>5}, {:x=>8, :y=>5}, {:x=>8, :y=>4}], :inner=>[]}]
+```
+
 Multithreaded contour processing is supported. However, on Ruby MRI (the standard Ruby implementation, at least up to 3.x), the Global Interpreter Lock (GIL) prevents more than one thread from executing Ruby code simultaneously. As a consequence, execution remains effectively serialized even on multicore systems, unless the gem is used under JRuby or TruffleRuby (not tested).
 
 ```ruby
@@ -162,6 +219,26 @@ result = Contrek.contour!(
 )
 ```
 
+## Tracing Modes
+
+Contrek provides two levels of precision for polygon generation to balance data density and topological accuracy.
+
+### **Standard Mode** (Default)
+Optimized for **speed** and **lightweight** output.
+* **Behavior:** Traces outer boundaries while simplifying collinear segments.
+* **Result:** Fewer vertices and smaller memory footprint.
+
+### **Strict Mode** (`strict_bounds: true`)
+Engineered for **Pixel-Perfect** precision.
+* **Behavior:** Preserves every junction and internal connectivity change.
+* **Result:** 100% topologically faithful geometry with no micro-gaps between adjacent polygons.
+
+Below are two images illustrating the difference in tracing modes. In the first case, with **strict_bounds ON**, the anti-clockwise sequence includes two additional points, **H** and **I**, which trace the shape more accurately. In the second case, the transition between **G** and **H** is approximated, omitting the indentation.
+| Strict Bounds ON | Strict Bounds OFF |
+|:---:|:---:|
+| ![Originale](./docs/images/strict_bounds_on.png) | ![Poligoni](./docs/images/strict_bounds_off.png) |
+
+
 ## Result
 
 The result structure contains polygon coordinates and a set of metadata. Polygon coordinates can be accessed via:

data/ext/cpp_polygon_finder/PolygonFinder/examples/example.cpp

@@ -21,7 +21,10 @@ void run_test() {
   // test_suite.test_c();
   // test_suite.test_d();
   // test_suite.test_e();
-  test_suite.test_f();
+  // test_suite.test_f();
+  // test_suite.test_g();
+  // test_suite.test_h();
+  test_suite.test_i();
   std::cout << "compute time =" << cpu_timer.stop() << std::endl;
 }
 

data/ext/cpp_polygon_finder/PolygonFinder/src/Tests.cpp

@@ -14,17 +14,24 @@
 #include <map>
 #include <vector>
 #include <string>
+#include <cstring>
+#include <algorithm>
+#include <cstdio>
 #include "polygon/finder/PolygonFinder.h"
 #include "polygon/finder/concurrent/ClippedPolygonFinder.h"
 #include "polygon/bitmaps/Bitmap.h"
 #include "polygon/bitmaps/FastPngBitmap.h"
+#include "polygon/bitmaps/RawBitmap.h"
 #include "polygon/bitmaps/RemoteFastPngBitmap.h"
+#include "polygon/bitmaps/spng.h"
 #include "polygon/matchers/Matcher.h"
 #include "polygon/matchers/RGBMatcher.h"
 #include "polygon/matchers/RGBNotMatcher.h"
 #include "polygon/matchers/ValueNotMatcher.h"
 #include "polygon/finder/optionparser.h"
 #include "polygon/finder/concurrent/Finder.h"
+#include "polygon/finder/concurrent/HorizontalMerger.h"
+#include "polygon/finder/concurrent/VerticalMerger.h"
 #include "polygon/finder/concurrent/Sequence.h"
 #include "polygon/finder/concurrent/Position.h"
 #include "polygon/finder/Polygon.h"
@@ -44,6 +51,7 @@ void Tests::test_a()
   Bitmap b(chunk, 16);
   PolygonFinder pl(&b, &matcher, nullptr, &arguments);
   ProcessResult *o = pl.process_info();
+  // o->print_polygons();
   std::vector<int> outer_array{11, 1, 6, 2, 6, 3, 6, 4, 6, 5, 11, 5, 11, 4, 11, 3, 11, 2, 11, 1};
   std::vector<int> inner_array{7, 3, 10, 3, 10, 4, 7, 4};
   std::vector<int> array_compare;
@@ -141,7 +149,7 @@ void Tests::test_d()
   FastPngBitmap png_bitmap("../images/sample_10240x10240.png");
   // FastPngBitmap png_bitmap("images/labyrinth.png");
   std::cout << "image_w=" << png_bitmap.w() << " image_h=" << png_bitmap.h() << std::endl;
-  std::cout << "immagine =" << cpu_timer.stop() << std::endl;
+  std::cout << "image reading time =" << cpu_timer.stop() << std::endl;
 
   int color = png_bitmap.value_at(0, 0);
   std::cout << "color =" << color << std::endl;
@@ -169,7 +177,7 @@ void Tests::test_e()
   Finder pl(2, &png_bitmap, &not_matcher, &arguments);
   ProcessResult *o = pl.process_info();
   o->print_info();
-  std::cout << "polygons =" << o->groups << std::endl;
+  std::cout << "polygons = " << o->groups << std::endl;
   delete o;
 }
 
@@ -184,3 +192,177 @@ void Tests::test_f()
   std::cout << "image_w=" << bitmap.w() << " image_h=" << bitmap.h() << std::endl;
   std::cout << "load_error=" << bitmap.error() << std::endl;
 }
+
+void Tests::test_g()
+{ RawBitmap raw_bitmap;
+  raw_bitmap.define(50, 50, 4);
+
+  // draw a polygon start_x = 5, start_y = 4, end_x = 8, end_y = 5
+  for (int y : {4, 5}) {
+    for (int x = 5; x <= 8; ++x) {
+      raw_bitmap.draw_pixel(x, y, 1, 0, 0);
+    }
+  }
+
+  int color = raw_bitmap.rgb_value_at(0, 0);
+  std::cout << "color = " << color << std::endl;
+  RGBNotMatcher not_matcher(color);
+
+  std::vector<std::string> arguments = {"--versus=a", "--compress_uniq", "--number_of_tiles=2"};
+  Finder pl(2, &raw_bitmap, &not_matcher, &arguments);
+  ProcessResult *o = pl.process_info();
+  // o->print_info();
+  // o->print_polygons();
+  std::cout << "polygons = " << o->groups << std::endl;
+  delete o;
+}
+
+void Tests::test_h()
+{ std::string left =
+              "0000000000" \
+              "0000000000" \
+              "00        " \
+              "00        " \
+              "00        " \
+              "00        " \
+              "00        " \
+              "0000000000" \
+              "0000000000";
+  std::vector<std::string> arguments = {"--versus=a", "--compress_uniq"};
+  ValueNotMatcher matcher(' ');
+  Bitmap b_left(left, 10);
+  PolygonFinder pl_left(&b_left, &matcher, nullptr, &arguments);
+  ProcessResult *left_result = pl_left.process_info();
+
+  std::string right =
+              "0000000000" \
+              "0000000000" \
+              "      0000" \
+              "      0000" \
+              "      0000" \
+              "      0000" \
+              "      0000" \
+              "0000000000" \
+              "0000000000";
+  Bitmap b_right(right, 10);
+  PolygonFinder pl_right(&b_right, &matcher, nullptr, &arguments);
+  ProcessResult *right_result = pl_right.process_info();
+
+  std::vector<std::string> merger_arguments = {};
+  HorizontalMerger hmerger(1, &arguments);
+  hmerger.add_tile(*left_result);
+  hmerger.add_tile(*right_result);
+  ProcessResult *merged_result = hmerger.process_info();
+  merged_result->print_polygons();
+
+  delete merged_result;
+  delete left_result;
+  delete right_result;
+}
+
+/* In this example, PNG data is read by streaming into a user-defined buffer height.
+  Contrek scans each stripe and extracts the polygons. Finally, it merges all
+  polygons from every stripe as if they had been read from a single image and saves
+  the result polygons on a png image.
+  This approach allows for processing large PNG files on systems where memory
+  would otherwise be insufficient.
+*/
+void stream_png_image(const std::string& filepath, uint32_t stripe_height) {
+    std::vector<ProcessResult*> result_clones;
+    std::vector<std::string> varguments = {};
+    VerticalMerger vmerger(0, &varguments);
+
+    // opens image to stream
+    FILE* fp = fopen(filepath.c_str(), "rb");
+    if (!fp) {
+      std::cerr << "Unable open file: " << filepath << std::endl;
+      return;
+    }
+
+    // exams image
+    spng_ctx *ctx = spng_ctx_new(0);
+    spng_set_png_file(ctx, fp);
+    struct spng_ihdr ihdr;
+    if (spng_get_ihdr(ctx, &ihdr)) {
+      fclose(fp);
+      spng_ctx_free(ctx);
+      return;
+    }
+    uint32_t total_width = ihdr.width;
+    uint32_t total_height = ihdr.height;
+
+    // allocates stripe buffer
+    RawBitmap stripe_bitmap;
+    stripe_bitmap.define(total_width, stripe_height, 4, true);
+    RGBNotMatcher not_matcher(-1);
+
+    if (spng_decode_image(ctx, NULL, 0, SPNG_FMT_RGBA8, SPNG_DECODE_PROGRESSIVE)) {
+      fclose(fp);
+      spng_ctx_free(ctx);
+      return;
+    }
+
+    size_t row_size = static_cast<size_t>(total_width) * 4;
+    // main strpes loop
+    for (uint32_t current_y_offset = 0; current_y_offset < total_height; current_y_offset += stripe_height) {
+      int uncovered_height = total_height - current_y_offset;
+
+      // copy previous last line to the next new one (each contigue stripe must share one pixel scanline)
+      if (current_y_offset > 0) {
+        unsigned char* last_row_prev = const_cast<unsigned char*>(stripe_bitmap.get_row_ptr(stripe_height - 1));
+        unsigned char* first_row_curr = const_cast<unsigned char*>(stripe_bitmap.get_row_ptr(0));
+        std::memcpy(first_row_curr, last_row_prev, row_size);
+      }
+      // clears the part of the stripe wont be overwritten by png data
+      if (uncovered_height < stripe_height)
+      { stripe_bitmap.draw_filled_rectangle(0, 1, total_width, stripe_height - 1, 255, 255, 255);
+      }
+      // decoding data directly in the stripe buffer
+      uint32_t lines_to_read = std::min(stripe_height, total_height - current_y_offset);
+      for (uint32_t y = (current_y_offset == 0 ? 0 : 1); y < lines_to_read; y++) {
+        unsigned char* row_ptr = const_cast<unsigned char*>(stripe_bitmap.get_row_ptr(y));
+        int ret = spng_decode_row(ctx, row_ptr, row_size);
+        if (ret != 0 && ret != SPNG_EOI) break;
+      }
+      // stripe contour tracing
+      std::vector<std::string> finder_arguments = {
+        "--versus=a",
+        "--strict_bounds"  // <- this option is strictly needed when working with vertical merger
+      };
+      PolygonFinder polygon_finder(&stripe_bitmap, &not_matcher, nullptr, &finder_arguments);
+      ProcessResult *result = polygon_finder.process_info();
+      if (result) {
+        std::cout << "Founds polygons: " << result->groups << std::endl;
+        ProcessResult* safe_result = result->clone();
+        result_clones.push_back(safe_result);
+        vmerger.add_tile(*safe_result);
+        delete result;
+      }
+    }
+
+    std::cout << "Merging polygons ..." << std::endl;
+    ProcessResult *merged_result = vmerger.process_info();
+    std::cout << "Founds total polygons: " << merged_result->groups << std::endl;
+
+    if (merged_result) {
+      RawBitmap full_bitmap;
+      full_bitmap.define(total_width, total_height, 4, true);
+      full_bitmap.fill(255, 255, 255);
+      merged_result->draw_on_bitmap(full_bitmap);
+      std::cout << "Saving whole png ..." << std::endl;
+      if (full_bitmap.save_to_png("whole.png")) {
+        std::cout << "Png saved!" << std::endl;
+      }
+    }
+    delete merged_result;
+    // frees memory
+    for (auto c : result_clones) {
+      delete c;
+    }
+    spng_ctx_free(ctx);
+    fclose(fp);
+}
+
+void Tests::test_i() {
+  stream_png_image("../images/graphs_1024x1024.png", 300);
+}

data/ext/cpp_polygon_finder/PolygonFinder/src/Tests.h

@@ -17,4 +17,7 @@ class Tests {
   virtual void test_d();
   virtual void test_e();
   virtual void test_f();
+  virtual void test_g();
+  virtual void test_h();
+  virtual void test_i();
 };

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/FastPngBitmap.cpp

@@ -20,74 +20,38 @@
 #include "FastPngBitmap.h"
 #include "spng.h"
 
-FastPngBitmap::FastPngBitmap(std::string filename) : Bitmap("", 0) {
-  if (filename.length() > 0)
-  { std::ifstream file(filename, std::ios::binary | std::ios::ate);
-    if (file.is_open())
-    { std::streamsize size = file.tellg();
+FastPngBitmap::FastPngBitmap(std::string filename) : RawBitmap() {
+  if (filename.length() > 0) {
+    std::ifstream file(filename, std::ios::binary | std::ios::ate);
+    if (file.is_open()) {
+      std::streamsize size = file.tellg();
       file.seekg(0, std::ios::beg);
       std::vector<unsigned char> file_buffer(size);
-      if (!file.read(reinterpret_cast<char*>(file_buffer.data()), size))
-      { this->png_error = -1;
+      if (!file.read(reinterpret_cast<char*>(file_buffer.data()), size)) {
+        this->png_error = -1;
       } else {
         spng_ctx *ctx = spng_ctx_new(0);
         spng_set_png_buffer(ctx, file_buffer.data(), file_buffer.size());
         struct spng_ihdr ihdr;
         spng_get_ihdr(ctx, &ihdr);
-        this->width = ihdr.width;
-        this->height = ihdr.height;
         size_t out_size;
         spng_decoded_image_size(ctx, SPNG_FMT_RGBA8, &out_size);
-        this->image.resize(out_size);
-        madvise(this->image.data(), out_size, MADV_HUGEPAGE);
-        int error = spng_decode_image(ctx, image.data(), out_size, SPNG_FMT_RGBA8, SPNG_DECODE_TRNS);
+        this->define(ihdr.width, ihdr.height, 4, false);
+        unsigned char* raw_ptr = this->image.get();
+        madvise(raw_ptr, out_size, MADV_HUGEPAGE);
+        int error = spng_decode_image(ctx, raw_ptr, out_size, SPNG_FMT_RGBA8, SPNG_DECODE_TRNS);
         spng_ctx_free(ctx);
         this->png_error = error;
       }
     } else {
-      throw std::runtime_error("Unable open file: " + filename);
+      throw std::runtime_error("Unable to open file: " + filename);
     }
   }
 }
 
-bool FastPngBitmap::pixel_match(int x, int y, Matcher *matcher)
-{ int32_t index = ((y * width) + x) * 4;
-  unsigned int color;
-  unsigned char *red = &image[index];
-  std::memcpy(&color, red, 3);
-  if (typeid(*matcher) == typeid(RGBMatcher))  return((reinterpret_cast<RGBMatcher*>(matcher))->match(color));
-  if (typeid(*matcher) == typeid(RGBNotMatcher)) return((reinterpret_cast<RGBNotMatcher*>(matcher))->match(color));
-  return(false);
-}
-
-int FastPngBitmap::w() {
-  return this->width;
-}
-
-int FastPngBitmap::h() {
-  return this->height;
-}
-
 int FastPngBitmap::error() {
   return this->png_error;
 }
-char FastPngBitmap::value_at(int x, int y) {
-  return(0);
-}
-
-// source image format RGBA => returning uint ABGR
-unsigned int FastPngBitmap::rgb_value_at(int x, int y) {
-  uint32_t index = (uint32_t(y) * width + x) * 4;
-  return *reinterpret_cast<const uint32_t*>(&image[index]);
-}
-
-const unsigned char* FastPngBitmap::get_row_ptr(int y) const {
-  return image.data() + (static_cast<size_t>(y) * static_cast<size_t>(width) * 4);
-}
-
-int FastPngBitmap::get_bytes_per_pixel() const {
-  return 4;  // RGBA
-}
 
 void FastPngBitmap::loadFile(std::vector<unsigned char>& buffer, const std::string& filename)  // designed for loading files from hard disk in an std::vector
 { std::ifstream file(filename.c_str(), std::ios::in|std::ios::binary|std::ios::ate);

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/FastPngBitmap.h

@@ -11,29 +11,20 @@
 #include <vector>
 #include <cstddef>
 #include <string>
-#include "Bitmap.h"
+#include "RawBitmap.h"
 
 class RGBMatcher;
 
 static const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
-class FastPngBitmap : public Bitmap {
+class FastPngBitmap : public RawBitmap {
  public:
   explicit FastPngBitmap(std::string filename);
-  bool pixel_match(int x, int y, Matcher *matcher);
-  int h();
-  int w();
   virtual int error();
-  char value_at(int x, int y);
-  unsigned int rgb_value_at(int x, int y);
-  const unsigned char* get_row_ptr(int y) const;
-  int get_bytes_per_pixel() const;
 
  protected:
   std::vector<unsigned char> buffer;
   std::vector<unsigned char> base64_decode(std::string &encoded_string);
-  std::vector<unsigned char> image;
-  unsigned int width, height;
   int png_error;
   int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width, unsigned long& image_height, const unsigned char* in_png, size_t in_size, bool convert_to_rgba32 = true);