Feature guard

* Added maturin-based Python binding, to be deployed to https://pypi.org/project/vtracer/

* Removed poetry mentions from pyproject.toml, added README_PY.md for use on PYPI

* ->   v0.6.1
-> moved Python bindings to bottom of converter.rs

* - README_PY.md needed to be inside the cmdapp directory to display on PyPi.irg
->  v0.6.3

.github/workflows/CI.yml

@@ -0,0 +1,117 @@
+# This file is autogenerated by maturin v1.2.3
+# To update, run
+#
+#    maturin generate-ci github
+#
+name: CI
+
+on:
+  push:
+    tags:
+      - '*'
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  linux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [x86_64, x86, aarch64, armv7, s390x, ppc64le]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist --find-interpreter
+          sccache: 'true'
+          manylinux: auto
+      - name: Upload wheels
+        uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: dist
+
+  windows:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        target: [x64, x86]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+          architecture: ${{ matrix.target }}
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist --find-interpreter
+          sccache: 'true'
+      - name: Upload wheels
+        uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: dist
+
+  macos:
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        target: [x86_64, aarch64]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist --find-interpreter
+          sccache: 'true'
+      - name: Upload wheels
+        uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: dist
+
+  sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Build sdist
+        uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out dist
+      - name: Upload sdist
+        uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: dist
+
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    if: "startsWith(github.ref, 'refs/tags/')"
+    needs: [linux, windows, macos, sdist]
+    steps:
+      - uses: actions/download-artifact@v3
+        with:
+          name: wheels
+      - name: Publish to PyPI
+        uses: PyO3/maturin-action@v1
+        env:
+          MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+        with:
+          command: upload
+          args: --non-interactive --skip-existing *

.github/workflows/python.yml

@@ -1,183 +0,0 @@
-# This file is autogenerated by maturin v1.11.5
-# To update, run
-#
-#    maturin generate-ci github
-#
-name: Python
-
-on:
-  push:
-    tags:
-      - '*'
-  pull_request:
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  linux:
-    runs-on: ${{ matrix.platform.runner }}
-    strategy:
-      matrix:
-        platform:
-          - runner: ubuntu-22.04
-            target: x86_64
-          - runner: ubuntu-22.04
-            target: x86
-          - runner: ubuntu-22.04
-            target: aarch64
-          - runner: ubuntu-22.04
-            target: armv7
-          - runner: ubuntu-22.04
-            target: s390x
-          - runner: ubuntu-22.04
-            target: ppc64le
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-      - name: Build wheels
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.platform.target }}
-          args: --release --out dist --find-interpreter --manifest-path cmdapp/Cargo.toml
-          sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
-          manylinux: auto
-      - name: Upload wheels
-        uses: actions/upload-artifact@v5
-        with:
-          name: wheels-linux-${{ matrix.platform.target }}
-          path: dist
-
-  musllinux:
-    runs-on: ${{ matrix.platform.runner }}
-    strategy:
-      matrix:
-        platform:
-          - runner: ubuntu-22.04
-            target: x86_64
-          - runner: ubuntu-22.04
-            target: x86
-          - runner: ubuntu-22.04
-            target: aarch64
-          - runner: ubuntu-22.04
-            target: armv7
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-      - name: Build wheels
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.platform.target }}
-          args: --release --out dist --find-interpreter --manifest-path cmdapp/Cargo.toml
-          sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
-          manylinux: musllinux_1_2
-      - name: Upload wheels
-        uses: actions/upload-artifact@v5
-        with:
-          name: wheels-musllinux-${{ matrix.platform.target }}
-          path: dist
-
-  windows:
-    runs-on: ${{ matrix.platform.runner }}
-    strategy:
-      matrix:
-        platform:
-          - runner: windows-latest
-            target: x64
-            python_arch: x64
-          - runner: windows-latest
-            target: x86
-            python_arch: x86
-          - runner: windows-11-arm
-            target: aarch64
-            python_arch: arm64
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
-        with:
-          python-version: 3.13
-          architecture: ${{ matrix.platform.python_arch }}
-      - name: Build wheels
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.platform.target }}
-          args: --release --out dist --find-interpreter --manifest-path cmdapp/Cargo.toml
-          sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
-      - name: Upload wheels
-        uses: actions/upload-artifact@v5
-        with:
-          name: wheels-windows-${{ matrix.platform.target }}
-          path: dist
-
-  macos:
-    runs-on: ${{ matrix.platform.runner }}
-    strategy:
-      matrix:
-        platform:
-          - runner: macos-15-intel
-            target: x86_64
-          - runner: macos-latest
-            target: aarch64
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-      - name: Build wheels
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.platform.target }}
-          args: --release --out dist --find-interpreter --manifest-path cmdapp/Cargo.toml
-          sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
-      - name: Upload wheels
-        uses: actions/upload-artifact@v5
-        with:
-          name: wheels-macos-${{ matrix.platform.target }}
-          path: dist
-
-  sdist:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - name: Build sdist
-        uses: PyO3/maturin-action@v1
-        with:
-          command: sdist
-          args: --out dist --manifest-path cmdapp/Cargo.toml
-      - name: Upload sdist
-        uses: actions/upload-artifact@v5
-        with:
-          name: wheels-sdist
-          path: dist
-
-  release:
-    name: Release
-    runs-on: ubuntu-latest
-    # Specifying a GitHub environment is optional, but strongly encouraged
-    environment: python
-    if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
-    needs: [linux, musllinux, windows, macos, sdist]
-    permissions:
-      # Use to sign the release artifacts
-      id-token: write
-      # Used to upload release artifacts
-      contents: write
-      # Used to generate artifact attestation
-      attestations: write
-    steps:
-      - uses: actions/download-artifact@v6
-      - name: Generate artifact attestation
-        uses: actions/attest-build-provenance@v3
-        with:
-          subject-path: 'wheels-*/*'
-      - name: Install uv
-        if: ${{ startsWith(github.ref, 'refs/tags/') }}
-        uses: astral-sh/setup-uv@v7
-      - name: Publish to PyPI
-        if: ${{ startsWith(github.ref, 'refs/tags/') }}
-        run: uv publish 'wheels-*/*'

.github/workflows/release.yml

@@ -1,30 +0,0 @@
-name: Release
-
-on:
-  release:
-    types: [published]
-
-jobs:
-  release:
-    strategy:
-      matrix:
-        include:
-          - target: aarch64-unknown-linux-musl
-            os: ubuntu-latest
-          - target: x86_64-unknown-linux-musl
-            os: ubuntu-latest
-          - target: aarch64-apple-darwin
-            os: macos-latest
-          - target: x86_64-apple-darwin
-            os: macos-latest
-          - target: x86_64-pc-windows-msvc
-            os: windows-latest
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: taiki-e/upload-rust-binary-action@v1
-        with:
-          bin: vtracer
-          target: ${{ matrix.target }}
-          # (required) GitHub token for uploading assets to GitHub Releases.
-          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/rust.yml

@@ -1,23 +1,10 @@
 name: Rust
 
 on:
-  pull_request:
-    paths-ignore:
-      - '**.md'
-      - '.github/ISSUE_TEMPLATE/**'
   push:
-    paths-ignore:
-      - '**.md'
-      - '.github/ISSUE_TEMPLATE/**'
-    branches:
-      - master
-      - 0.*.x
-      - pr/**/ci
-      - ci-*
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.ref || github.run_id }}
-  cancel-in-progress: true
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
 
 env:
   CARGO_TERM_COLOR: always

CHANGELOG.md

@@ -5,35 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
-## 0.6.12 - 2026-02-04
+## 0.6.0 - 2023-09-08
 
 * Python Binding
 
-## 0.6.5 - 2025-10-17
-
-* Update `fastrand` to `2.3`
-
-## 0.6.4 - 2024-03-29
-
-* Update `visioncortex` version to `0.8.8`
-
-## 0.6.3 - 2023-11-21
-
-* New converter API https://github.com/visioncortex/vtracer/pull/59
-
-## 0.6.1 - 2023-09-23
-
-* Fixed "The two lines are parallel!"
-
-### Python Binding
-
-Thanks to the contribution of [@etjones](https://github.com/etjones), we now have an official Python binding! https://github.com/visioncortex/vtracer/pull/55
-
-https://pypi.org/project/vtracer/0.6.10/
-
 ## 0.5.0 - 2022-10-09
 
-* Handle transparent png images (cli) https://github.com/visioncortex/vtracer/pull/23
+* Handle transparent png images (cli) (#23)
 
 ## 0.4.0 - 2021-07-23
 
@@ -47,10 +25,6 @@ https://pypi.org/project/vtracer/0.6.10/
 
 * Use relative & closed paths
 
-## 0.1.1 - 2020-11-01
-
-* SVG namespace
-
 ## 0.1.0 - 2020-10-31
 
 * Initial release

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2024 TSANG, Hao Fung
+Copyright (c) 2022 Tsang Hao Fung
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

README.md

@@ -4,31 +4,31 @@
   <h1>VTracer</h1>
 
   <p>
-    <strong>Raster to Vector Graphics Converter</strong>
+    <strong>Raster to Vector Graphics Converter built on top of visioncortex</strong>
   </p>
 
   <h3>
-    <a href="https://www.visioncortex.org/vtracer-docs">Article</a>
+    <a href="//www.visioncortex.org/vtracer-docs">Article</a>
     <span> | </span>
-    <a href="https://www.visioncortex.org/vtracer/">Web App</a>
+    <a href="//www.visioncortex.org/vtracer/">Demo</a>
     <span> | </span>
-    <a href="https://github.com/visioncortex/vtracer/releases">Download</a>
+    <a href="//github.com/visioncortex/vtracer/releases/latest">Download</a>
   </h3>
 
-  <sub>Built with 🦀 by <a href="https://www.visioncortex.org/">The Vision Cortex Research Group</a></sub>
+  <sub>Built with 🦀 by <a href="//www.visioncortex.org/">The Vision Cortex Research Group</a></sub>
 </div>
 
 ## Introduction
 
 visioncortex VTracer is an open source software to convert raster images (like jpg & png) into vector graphics (svg). It can vectorize graphics and photographs and trace the curves to output compact vector files.
 
-Comparing to [Potrace](http://potrace.sourceforge.net/) which only accept binarized inputs (Black & White pixmap), VTracer has an image processing pipeline which can handle colored high resolution scans. tl;dr: Potrace uses a `O(n^2)` fitting algorithm, whereas `vtracer` is entirely `O(n)`.
+Comparing to [Potrace](http://potrace.sourceforge.net/) which only accept binarized inputs (Black & White pixmap), VTracer has an image processing pipeline which can handle colored high resolution scans.
 
 Comparing to Adobe Illustrator's [Image Trace](https://helpx.adobe.com/illustrator/using/image-trace.html), VTracer's output is much more compact (less shapes) as we adopt a stacking strategy and avoid producing shapes with holes.
 
 VTracer is originally designed for processing high resolution scans of historic blueprints up to gigapixels. At the same time, VTracer can also handle low resolution pixel art, simulating `image-rendering: pixelated` for retro game artworks.
 
-Technical descriptions of the [tracing algorithm](https://www.visioncortex.org/vtracer-docs) and [clustering algorithm](https://www.visioncortex.org/impression-docs).
+A technical description of the algorithm is on [visioncortex.org/vtracer-docs](//www.visioncortex.org/vtracer-docs).
 
 ## Web App
 
@@ -41,7 +41,7 @@ VTracer and its [core library](//github.com/visioncortex/visioncortex) is implem
 ## Cmd App
 
 ```sh
-visioncortex VTracer 0.6.0
+visioncortex VTracer 0.4.0
 A cmd app to convert images into vector graphics.
 
 USAGE:
@@ -71,43 +71,30 @@ OPTIONS:
     -s, --splice_threshold <splice_threshold>    Minimum angle displacement (degree) to splice a spline
 ```
 
-## Downloads
-
-You can download pre-built binaries from [Releases](https://github.com/visioncortex/vtracer/releases).
-
-You can also install the program from source from [crates.io/vtracer](https://crates.io/crates/vtracer):
-
-```sh
-cargo install vtracer
-```
-
-> You are strongly advised to not download from any other third-party sources 
-
 ### Usage
-
-```sh
+```
 ./vtracer --input input.jpg --output output.svg
 ```
 
-### Rust Library
+## Library
 
-You can install [`vtracer`](https://crates.io/crates/vtracer) as a Rust library.
+The library can be found on [crates.io/vtracer](//crates.io/crates/vtracer) and [crates.io/vtracer-webapp](//crates.io/crates/vtracer-webapp).
+
+## Install
+
+Download pre-built binaries from [Releases](https://github.com/visioncortex/vtracer/releases).
+
+or
+
+Install from source (Rust toolchain needed):
 
-```sh
-cargo add vtracer
 ```
-
-### Python Library
-
-Since `0.6`, [`vtracer`](https://pypi.org/project/vtracer/) is also packaged as Python native extensions, thanks to the awesome [pyo3](https://github.com/PyO3/pyo3) project.
-
-```sh
-pip install vtracer
+cargo install vtracer
 ```
 
 ## In the wild
 
-VTracer is used by the following products (open a PR to add yours):
+VTracer is used by the following products (feel free to add yours to the list):
 
 <table>
   <tbody>
@@ -119,39 +106,3 @@ VTracer is used by the following products (open a PR to add yours):
     </tr>
   </tbody>
 </table>
-
-## Citations
-
-VTracer has since been cited by a few academic papers in computer graphics / vision research. Please kindly let us know if you have cited our work:
-
-+ SKILL 2023 [Framework to Vectorize Digital Artworks for Physical Fabrication based on Geometric Stylization Techniques](https://www.researchgate.net/publication/374448489_Framework_to_Vectorize_Digital_Artworks_for_Physical_Fabrication_based_on_Geometric_Stylization_Techniques)
-+ arXiv 2023 [Image Vectorization: a Review](https://arxiv.org/abs/2306.06441)
-+ arXiv 2023 [StarVector: Generating Scalable Vector Graphics Code from Images](https://arxiv.org/abs/2312.11556)
-+ arXiv 2024 [Text-Based Reasoning About Vector Graphics](https://arxiv.org/abs/2404.06479)
-+ arXiv 2024 [Delving into LLMs' visual understanding ability using SVG to bridge image and text](https://openreview.net/pdf?id=pwlm6Po61I)
-
-## How did VTracer come about?
-
-> The following content is an excerpt from my [unpublished memoir](https://github.com/visioncortex/memoir).
-
-At my teenage, two open source projects in the vector graphics space inspired me the most: Potrace and Anti-Grain Geometry (AGG).
-
-Many years later, in 2020, I was developing a video processing engine. And it became evident that it requires way more investment to be commercially viable. So before abandoning the project, I wanted to publish *something* as open-source for posterity. At that time, I already developed a prototype vector graphics tracer. It can convert high-resolution scans of hand-drawn blueprints into vectors. But it can only process black and white images, and can only output polygons, not splines.
-
-The plan was to fully develop the vectorizer: to handle color images and output splines. I recruited a very talented intern, [@shpun817](https://github.com/shpun817), to work on VTracer. I grafted the frontend of the video processing engine - the ["The Clustering Algorithm"](https://www.visioncortex.org/impression-docs#the-clustering-algorithm) as the pre-processor.
-
-Three months later, we published the first version on Reddit. Out of my surprise, the response of such an underwhelming project was overwhelming.
-
-## What's next?
-
-There are several things in my mind:
-
-1. Path simplification. Implement a post-process filter to the output paths to further reduce the number of splines.
-
-2. Perfect cut-out mode. Right now in cut-out mode, the shapes do not share boundaries perfectly, but have seams.
-
-3. Pencil tracing. Instead of tracing shapes as closed paths, may be we can attempt to skeletonize the shapes as open paths. The output would be clean, fixed width strokes.
-
-4. Image cleaning. Right now the tracer works best on losslessly compressed pngs. If an image suffered from jpeg noises, it could impact the tracing quality. We might be able to develop a pre-filtering pass that denoises the input.
-
-If you are interested in working on them or willing to sponsor its development, feel free to get in touch.

RELEASES.md

@@ -0,0 +1,27 @@
+# Version 0.6.0 (2023-09-08)
+
+-   Python bindings
+
+# Version 0.5.0 (2022-10-09)
+
+-   Handle transparent png images
+
+# Version 0.4.0 (2021-07-23)
+
+-   SVG path string numeric precision
+
+# Version 0.3.0 (2021-01-24)
+
+-   Added cutout mode
+
+# Version 0.2.0 (2020-11-15)
+
+-   Use relative & closed paths
+
+# Version 0.1.1 (2020-11-01)
+
+-   SVG namespace
+
+# Version 0.1.0 (2020-10-31)
+
+-   Initial release

cmdapp/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vtracer"
-version = "0.6.12"
+version = "0.6.3"
 authors = ["Chris Tsang <chris.2y3@outlook.com>"]
 edition = "2021"
 description = "A cmd app to convert images into vector graphics."
@@ -13,14 +13,9 @@ keywords = ["svg", "computer-graphics"]
 [dependencies]
 clap = "2.33.3"
 image = "0.23.10"
-visioncortex = { version = "0.8.8" }
-fastrand = { version = "2.3" }
+visioncortex = { version = "0.8.0" }
+fastrand = "1.8"
 pyo3 = { version = "0.19.0", optional = true }
 
 [features]
-python-binding = ["pyo3"]
-wasm = ["fastrand/js"]
-
-[lib]
-name = "vtracer"
-crate-type = ["rlib", "cdylib"]
+python-binding = ["pyo3"]

cmdapp/LICENSE-MIT

@@ -1,4 +1,4 @@
-Copyright (c) 2023 Tsang Hao Fung
+Copyright (c) 2022 Tsang Hao Fung
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

cmdapp/README.md

@@ -1,96 +0,0 @@
-<div align="center">
-
-  <img src="https://raw.githubusercontent.com/visioncortex/vtracer/master/docs/images/visioncortex-banner.png">
-  <h1>VTracer</h1>
-
-  <p>
-    <strong>Raster to Vector Graphics Converter built on top of visioncortex</strong>
-  </p>
-
-  <h3>
-    <a href="https://www.visioncortex.org/vtracer-docs">Article</a>
-    <span> | </span>
-    <a href="https://www.visioncortex.org/vtracer/">Demo</a>
-    <span> | </span>
-    <a href="https://github.com/visioncortex/vtracer/releases/latest">Download</a>
-  </h3>
-
-  <sub>Built with 🦀 by <a href="https://www.visioncortex.org/">The Vision Cortex Research Group</a></sub>
-</div>
-
-## Introduction
-
-visioncortex VTracer is an open source software to convert raster images (like jpg & png) into vector graphics (svg). It can vectorize graphics and photographs and trace the curves to output compact vector files.
-
-Comparing to [Potrace](http://potrace.sourceforge.net/) which only accept binarized inputs (Black & White pixmap), VTracer has an image processing pipeline which can handle colored high resolution scans.
-
-Comparing to Adobe Illustrator's [Image Trace](https://helpx.adobe.com/illustrator/using/image-trace.html), VTracer's output is much more compact (less shapes) as we adopt a stacking strategy and avoid producing shapes with holes.
-
-VTracer is originally designed for processing high resolution scans of historic blueprints up to gigapixels. At the same time, VTracer can also handle low resolution pixel art, simulating `image-rendering: pixelated` for retro game artworks.
-
-A technical description of the algorithm is on [visioncortex.org/vtracer-docs](https://www.visioncortex.org/vtracer-docs).
-
-## Cmd App
-
-```sh
-visioncortex VTracer 0.6.0
-A cmd app to convert images into vector graphics.
-
-USAGE:
-    vtracer [OPTIONS] --input <input> --output <output>
-
-FLAGS:
-    -h, --help       Prints help information
-    -V, --version    Prints version information
-
-OPTIONS:
-        --colormode <color_mode>                 True color image `color` (default) or Binary image `bw`
-    -p, --color_precision <color_precision>      Number of significant bits to use in an RGB channel
-    -c, --corner_threshold <corner_threshold>    Minimum momentary angle (degree) to be considered a corner
-    -f, --filter_speckle <filter_speckle>        Discard patches smaller than X px in size
-    -g, --gradient_step <gradient_step>          Color difference between gradient layers
-        --hierarchical <hierarchical>
-            Hierarchical clustering `stacked` (default) or non-stacked `cutout`. Only applies to color mode.
-
-    -i, --input <input>                          Path to input raster image
-    -m, --mode <mode>                            Curver fitting mode `pixel`, `polygon`, `spline`
-    -o, --output <output>                        Path to output vector graphics
-        --path_precision <path_precision>        Number of decimal places to use in path string
-        --preset <preset>                        Use one of the preset configs `bw`, `poster`, `photo`
-    -l, --segment_length <segment_length>
-            Perform iterative subdivide smooth until all segments are shorter than this length
-
-    -s, --splice_threshold <splice_threshold>    Minimum angle displacement (degree) to splice a spline
-```
-
-### Install
-
-You can download pre-built binaries from [Releases](https://github.com/visioncortex/vtracer/releases).
-
-You can also install the program from source from [crates.io/vtracer](https://crates.io/crates/vtracer):
-
-```sh
-cargo install vtracer
-```
-
-### Usage
-
-```sh
-./vtracer --input input.jpg --output output.svg
-```
-
-## Rust Library
-
-You can install [`vtracer`](https://crates.io/crates/vtracer) as a Rust library.
-
-```sh
-cargo add vtracer
-```
-
-## Python Library
-
-Since `0.6`, [`vtracer`](https://pypi.org/project/vtracer/) is also packaged as Python native extensions, thanks to the awesome [pyo3](https://github.com/PyO3/pyo3) project.
-
-```sh
-pip install vtracer
-```

cmdapp/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vtracer"
-version = "0.6.12"
+version = "0.6.3"
 description = "Python bindings for the Rust Vtracer raster-to-vector library"
 authors = [ { name = "Chris Tsang",  email = "chris.2y3@outlook.com" } ]
 readme = "vtracer/README.md"
@@ -23,6 +23,6 @@ requires = ["maturin>=1.2,<2.0"]
 build-backend = "maturin"
 
 [tool.maturin]
-features = ["pyo3/extension-module", "python-binding"]
-compatibility = "manylinux2014"
-sdist-include = ["LICENSE-MIT", "LICENSE-APACHE", "vtracer/README.md"]
+features = ["pyo3/extension-module"]
+compatibility = "linux"
+sdist-include = ["../LICENSE", "../README.md"]

cmdapp/src/config.rs

@@ -1,28 +1,28 @@
 use std::str::FromStr;
+use std::path::PathBuf;
+use clap::{Arg, App};
 use visioncortex::PathSimplifyMode;
 
-#[derive(Debug, Clone)]
 pub enum Preset {
     Bw,
     Poster,
-    Photo,
+    Photo
 }
 
-#[derive(Debug, Clone)]
 pub enum ColorMode {
     Color,
     Binary,
 }
 
-#[derive(Debug, Clone)]
 pub enum Hierarchical {
     Stacked,
     Cutout,
 }
 
 /// Converter config
-#[derive(Debug, Clone)]
 pub struct Config {
+    pub input_path: PathBuf,
+    pub output_path: PathBuf,
     pub color_mode: ColorMode,
     pub hierarchical: Hierarchical,
     pub filter_speckle: usize,
@@ -36,8 +36,9 @@ pub struct Config {
     pub path_precision: Option<u32>,
 }
 
-#[derive(Debug, Clone)]
 pub(crate) struct ConverterConfig {
+    pub input_path: PathBuf,
+    pub output_path: PathBuf,
     pub color_mode: ColorMode,
     pub hierarchical: Hierarchical,
     pub filter_speckle_area: usize,
@@ -54,6 +55,8 @@ pub(crate) struct ConverterConfig {
 impl Default for Config {
     fn default() -> Self {
         Self {
+            input_path: PathBuf::default(),
+            output_path: PathBuf::default(),
             color_mode: ColorMode::Color,
             hierarchical: Hierarchical::Stacked,
             mode: PathSimplifyMode::Spline,
@@ -64,7 +67,7 @@ impl Default for Config {
             length_threshold: 4.0,
             splice_threshold: 45,
             max_iterations: 10,
-            path_precision: Some(2),
+            path_precision: Some(8),
         }
     }
 }
@@ -106,10 +109,225 @@ impl FromStr for Preset {
     }
 }
 
+fn path_simplify_mode_from_str(s: &str) -> PathSimplifyMode {
+    match s {
+        "polygon" => PathSimplifyMode::Polygon,
+        "spline" => PathSimplifyMode::Spline,
+        "none" => PathSimplifyMode::None,
+        _ => panic!("unknown PathSimplifyMode {}", s),
+    }
+}
+
 impl Config {
-    pub fn from_preset(preset: Preset) -> Self {
+    pub fn from_args() -> Self {
+        let app = App::new("visioncortex VTracer ".to_owned() + env!("CARGO_PKG_VERSION"))
+            .about("A cmd app to convert images into vector graphics.");
+
+        let app = app.arg(Arg::with_name("input")
+            .long("input")
+            .short("i")
+            .takes_value(true)
+            .help("Path to input raster image")
+            .required(true));
+
+        let app = app.arg(Arg::with_name("output")
+            .long("output")
+            .short("o")
+            .takes_value(true)
+            .help("Path to output vector graphics")
+            .required(true));
+
+        let app = app.arg(Arg::with_name("color_mode")
+            .long("colormode")
+            .takes_value(true)
+            .help("True color image `color` (default) or Binary image `bw`"));
+
+        let app = app.arg(Arg::with_name("hierarchical")
+            .long("hierarchical")
+            .takes_value(true)
+            .help(
+                "Hierarchical clustering `stacked` (default) or non-stacked `cutout`. \
+                Only applies to color mode. "
+            ));
+
+        let app = app.arg(Arg::with_name("preset")
+            .long("preset")
+            .takes_value(true)
+            .help("Use one of the preset configs `bw`, `poster`, `photo`"));
+
+        let app = app.arg(Arg::with_name("filter_speckle")
+            .long("filter_speckle")
+            .short("f")
+            .takes_value(true)
+            .help("Discard patches smaller than X px in size"));
+
+        let app = app.arg(Arg::with_name("color_precision")
+            .long("color_precision")
+            .short("p")
+            .takes_value(true)
+            .help("Number of significant bits to use in an RGB channel"));
+
+        let app = app.arg(Arg::with_name("gradient_step")
+            .long("gradient_step")
+            .short("g")
+            .takes_value(true)
+            .help("Color difference between gradient layers"));
+
+        let app = app.arg(Arg::with_name("corner_threshold")
+            .long("corner_threshold")
+            .short("c")
+            .takes_value(true)
+            .help("Minimum momentary angle (degree) to be considered a corner"));
+
+        let app = app.arg(Arg::with_name("segment_length")
+            .long("segment_length")
+            .short("l")
+            .takes_value(true)
+            .help("Perform iterative subdivide smooth until all segments are shorter than this length"));
+
+        let app = app.arg(Arg::with_name("splice_threshold")
+            .long("splice_threshold")
+            .short("s")
+            .takes_value(true)
+            .help("Minimum angle displacement (degree) to splice a spline"));
+
+        let app = app.arg(Arg::with_name("mode")
+            .long("mode")
+            .short("m")
+            .takes_value(true)
+            .help("Curver fitting mode `pixel`, `polygon`, `spline`"));
+
+        let app = app.arg(Arg::with_name("path_precision")
+            .long("path_precision")
+            .takes_value(true)
+            .help("Number of decimal places to use in path string"));
+
+        // Extract matches
+        let matches = app.get_matches();
+
+        let mut config = Config::default();
+        let input_path = matches.value_of("input").expect("Input path is required, please specify it by --input or -i.");
+        let output_path = matches.value_of("output").expect("Output path is required, please specify it by --output or -o.");
+
+        if let Some(value) = matches.value_of("preset") {
+            config = Self::from_preset(Preset::from_str(value).unwrap(), input_path, output_path);
+        }
+
+        config.input_path = PathBuf::from(input_path);
+        config.output_path = PathBuf::from(output_path);
+
+        if let Some(value) = matches.value_of("color_mode") {
+            config.color_mode = ColorMode::from_str(if value.trim() == "bw" || value.trim() == "BW" {"binary"} else {"color"}).unwrap()
+        }
+
+        if let Some(value) = matches.value_of("hierarchical") {
+            config.hierarchical = Hierarchical::from_str(value).unwrap()
+        }
+
+        if let Some(value) = matches.value_of("mode") {
+            let value = value.trim();
+            config.mode = path_simplify_mode_from_str(if value == "pixel" {
+                "none"
+            } else if value == "polygon" {
+                "polygon"
+            } else if value == "spline" {
+                "spline"
+            } else {
+                panic!("Parser Error: Curve fitting mode is invalid: {}", value);
+            });
+        }
+
+        if let Some(value) = matches.value_of("filter_speckle") {
+            if value.trim().parse::<usize>().is_ok() { // is numeric
+                let value = value.trim().parse::<usize>().unwrap();
+                if value > 16 {
+                    panic!("Out of Range Error: Filter speckle is invalid at {}. It must be within [0,16].", value);
+                }
+                config.filter_speckle = value;
+            } else {
+                panic!("Parser Error: Filter speckle is not a positive integer: {}.", value);
+            }
+        }
+
+        if let Some(value) = matches.value_of("color_precision") {
+            if value.trim().parse::<i32>().is_ok() { // is numeric
+                let value = value.trim().parse::<i32>().unwrap();
+                if value < 1 || value > 8 {
+                    panic!("Out of Range Error: Color precision is invalid at {}. It must be within [1,8].", value);
+                }
+                config.color_precision = value;
+            } else {
+                panic!("Parser Error: Color precision is not an integer: {}.", value);
+            }
+        }
+
+        if let Some(value) = matches.value_of("gradient_step") {
+            if value.trim().parse::<i32>().is_ok() { // is numeric
+                let value = value.trim().parse::<i32>().unwrap();
+                if value < 0 || value > 255 {
+                    panic!("Out of Range Error: Gradient step is invalid at {}. It must be within [0,255].", value);
+                }
+                config.layer_difference = value;
+            } else {
+                panic!("Parser Error: Gradient step is not an integer: {}.", value);
+            }
+        }
+
+        if let Some(value) = matches.value_of("corner_threshold") {
+            if value.trim().parse::<i32>().is_ok() { // is numeric
+                let value = value.trim().parse::<i32>().unwrap();
+                if value < 0 || value > 180 {
+                    panic!("Out of Range Error: Corner threshold is invalid at {}. It must be within [0,180].", value);
+                }
+                config.corner_threshold = value
+            } else {
+                panic!("Parser Error: Corner threshold is not numeric: {}.", value);
+            }
+        }
+
+        if let Some(value) = matches.value_of("segment_length") {
+            if value.trim().parse::<f64>().is_ok() { // is numeric
+                let value = value.trim().parse::<f64>().unwrap();
+                if value < 3.5 || value > 10.0 {
+                    panic!("Out of Range Error: Segment length is invalid at {}. It must be within [3.5,10].", value);
+                }
+                config.length_threshold = value;
+            } else {
+                panic!("Parser Error: Segment length is not numeric: {}.", value);
+            }
+        }
+
+        if let Some(value) = matches.value_of("splice_threshold") {
+            if value.trim().parse::<i32>().is_ok() { // is numeric
+                let value = value.trim().parse::<i32>().unwrap();
+                if value < 0 || value > 180 {
+                    panic!("Out of Range Error: Segment length is invalid at {}. It must be within [0,180].", value);
+                }
+                config.splice_threshold = value;
+            } else {
+                panic!("Parser Error: Segment length is not numeric: {}.", value);
+            }
+        }
+
+        if let Some(value) = matches.value_of("path_precision") {
+            if value.trim().parse::<u32>().is_ok() { // is numeric
+                let value = value.trim().parse::<u32>().ok();
+                config.path_precision = value;
+            } else {
+                panic!("Parser Error: Path precision is not an unsigned integer: {}.", value);
+            }
+        }
+
+        config
+    }
+
+    pub fn from_preset(preset: Preset, input_path: &str, output_path: &str) -> Self {
+        let input_path = PathBuf::from(input_path);
+        let output_path = PathBuf::from(output_path);
         match preset {
             Preset::Bw => Self {
+                input_path,
+                output_path,
                 color_mode: ColorMode::Binary,
                 hierarchical: Hierarchical::Stacked,
                 filter_speckle: 4,
@@ -120,9 +338,11 @@ impl Config {
                 length_threshold: 4.0,
                 max_iterations: 10,
                 splice_threshold: 45,
-                path_precision: Some(2),
+                path_precision: Some(8),
             },
             Preset::Poster => Self {
+                input_path,
+                output_path,
                 color_mode: ColorMode::Color,
                 hierarchical: Hierarchical::Stacked,
                 filter_speckle: 4,
@@ -133,9 +353,11 @@ impl Config {
                 length_threshold: 4.0,
                 max_iterations: 10,
                 splice_threshold: 45,
-                path_precision: Some(2),
+                path_precision: Some(8),
             },
             Preset::Photo => Self {
+                input_path,
+                output_path,
                 color_mode: ColorMode::Color,
                 hierarchical: Hierarchical::Stacked,
                 filter_speckle: 10,
@@ -146,13 +368,15 @@ impl Config {
                 length_threshold: 4.0,
                 max_iterations: 10,
                 splice_threshold: 45,
-                path_precision: Some(2),
-            },
+                path_precision: Some(8),
+            }
         }
     }
 
     pub(crate) fn into_converter_config(self) -> ConverterConfig {
         ConverterConfig {
+            input_path: self.input_path,
+            output_path: self.output_path,
             color_mode: self.color_mode,
             hierarchical: self.hierarchical,
             filter_speckle_area: self.filter_speckle * self.filter_speckle,
@@ -170,4 +394,4 @@ impl Config {
 
 fn deg2rad(deg: i32) -> f64 {
     deg as f64 / 180.0 * std::f64::consts::PI
-}
+}

cmdapp/src/converter.rs

@@ -1,43 +1,32 @@
-use std::path::Path;
+use std::path::PathBuf;
 use std::{fs::File, io::Write};
 
-use super::config::{ColorMode, Config, ConverterConfig, Hierarchical};
-use super::svg::SvgFile;
 use fastrand::Rng;
-use visioncortex::color_clusters::{KeyingAction, Runner, RunnerConfig, HIERARCHICAL_MAX};
 use visioncortex::{Color, ColorImage, ColorName};
+use visioncortex::color_clusters::{Runner, RunnerConfig, KeyingAction, HIERARCHICAL_MAX};
+use super::config::{Config, ColorMode, Hierarchical, ConverterConfig};
+use super::svg::SvgFile;
 
 const NUM_UNUSED_COLOR_ITERATIONS: usize = 6;
 /// The fraction of pixels in the top/bottom rows of the image that need to be transparent before
 /// the entire image will be keyed.
 const KEYING_THRESHOLD: f32 = 0.2;
 
-/// Convert an in-memory image into an in-memory SVG
-pub fn convert(img: ColorImage, config: Config) -> Result<SvgFile, String> {
+/// Convert an image file into svg file
+pub fn convert_image_to_svg(config: Config) -> Result<(), String> {
     let config = config.into_converter_config();
     match config.color_mode {
-        ColorMode::Color => color_image_to_svg(img, config),
-        ColorMode::Binary => binary_image_to_svg(img, config),
+        ColorMode::Color => color_image_to_svg(config),
+        ColorMode::Binary => binary_image_to_svg(config),
     }
 }
 
-/// Convert an image file into svg file
-pub fn convert_image_to_svg(
-    input_path: &Path,
-    output_path: &Path,
-    config: Config,
-) -> Result<(), String> {
-    let img = read_image(input_path)?;
-    let svg = convert(img, config)?;
-    write_svg(svg, output_path)
-}
-
 fn color_exists_in_image(img: &ColorImage, color: Color) -> bool {
     for y in 0..img.height {
         for x in 0..img.width {
             let pixel_color = img.get_pixel(x, y);
             if pixel_color.r == color.r && pixel_color.g == color.g && pixel_color.b == color.b {
-                return true;
+                return true
             }
         }
     }
@@ -46,24 +35,27 @@ fn color_exists_in_image(img: &ColorImage, color: Color) -> bool {
 
 fn find_unused_color_in_image(img: &ColorImage) -> Result<Color, String> {
     let special_colors = IntoIterator::into_iter([
-        Color::new(255, 0, 0),
-        Color::new(0, 255, 0),
-        Color::new(0, 0, 255),
+        Color::new(255, 0,   0),
+        Color::new(0,   255, 0),
+        Color::new(0,   0,   255),
         Color::new(255, 255, 0),
-        Color::new(0, 255, 255),
-        Color::new(255, 0, 255),
+        Color::new(0,   255, 255),
+        Color::new(255, 0,   255),
     ]);
-    let mut rng = Rng::new();
-    let random_colors =
-        (0..NUM_UNUSED_COLOR_ITERATIONS).map(|_| Color::new(rng.u8(..), rng.u8(..), rng.u8(..)));
+    let rng = Rng::new();
+    let random_colors = (0..NUM_UNUSED_COLOR_ITERATIONS).map(|_| {
+        Color::new(
+            rng.u8(..),
+            rng.u8(..),
+            rng.u8(..),
+        )
+    });
     for color in special_colors.chain(random_colors) {
         if !color_exists_in_image(img, color) {
             return Ok(color);
         }
     }
-    Err(String::from(
-        "unable to find unused color in image to use as key",
-    ))
+    Err(String::from("unable to find unused color in image to use as key"))
 }
 
 fn should_key_image(img: &ColorImage) -> bool {
@@ -73,20 +65,14 @@ fn should_key_image(img: &ColorImage) -> bool {
 
     // Check for transparency at several scanlines
     let threshold = ((img.width * 2) as f32 * KEYING_THRESHOLD) as usize;
-    let mut num_transparent_pixels = 0;
-    let y_positions = [
-        0,
-        img.height / 4,
-        img.height / 2,
-        3 * img.height / 4,
-        img.height - 1,
-    ];
+    let mut num_transparent_boundary_pixels = 0;
+    let y_positions = [0, img.height / 4, img.height / 2, 3 * img.height / 4, img.height - 1];
     for y in y_positions {
         for x in 0..img.width {
             if img.get_pixel(x, y).a == 0 {
-                num_transparent_pixels += 1;
+                num_transparent_boundary_pixels += 1;
             }
-            if num_transparent_pixels >= threshold {
+            if num_transparent_boundary_pixels >= threshold {
                 return true;
             }
         }
@@ -95,9 +81,16 @@ fn should_key_image(img: &ColorImage) -> bool {
     false
 }
 
-fn color_image_to_svg(mut img: ColorImage, config: ConverterConfig) -> Result<SvgFile, String> {
-    let width = img.width;
-    let height = img.height;
+fn color_image_to_svg(config: ConverterConfig) -> Result<(), String> {
+    let (mut img, width, height);
+    match read_image(config.input_path) {
+        Ok(values) => {
+            img = values.0;
+            width = values.1;
+            height = values.2;
+        },
+        Err(msg) => return Err(msg),
+    }
 
     let key_color = if should_key_image(&img) {
         let key_color = find_unused_color_in_image(&img)?;
@@ -114,26 +107,23 @@ fn color_image_to_svg(mut img: ColorImage, config: ConverterConfig) -> Result<Sv
         Color::default()
     };
 
-    let runner = Runner::new(
-        RunnerConfig {
-            diagonal: config.layer_difference == 0,
-            hierarchical: HIERARCHICAL_MAX,
-            batch_size: 25600,
-            good_min_area: config.filter_speckle_area,
-            good_max_area: (width * height),
-            is_same_color_a: config.color_precision_loss,
-            is_same_color_b: 1,
-            deepen_diff: config.layer_difference,
-            hollow_neighbours: 1,
-            key_color,
-            keying_action: if matches!(config.hierarchical, Hierarchical::Cutout) {
-                KeyingAction::Keep
-            } else {
-                KeyingAction::Discard
-            },
+    let runner = Runner::new(RunnerConfig {
+        diagonal: config.layer_difference == 0,
+        hierarchical: HIERARCHICAL_MAX,
+        batch_size: 25600,
+        good_min_area: config.filter_speckle_area,
+        good_max_area: (width * height),
+        is_same_color_a: config.color_precision_loss,
+        is_same_color_b: 1,
+        deepen_diff: config.layer_difference,
+        hollow_neighbours: 1,
+        key_color,
+        keying_action: if matches!(config.hierarchical, Hierarchical::Cutout) {
+            KeyingAction::Keep
+        } else {
+            KeyingAction::Discard
         },
-        img,
-    );
+    }, img);
 
     let mut clusters = runner.run();
 
@@ -142,24 +132,21 @@ fn color_image_to_svg(mut img: ColorImage, config: ConverterConfig) -> Result<Sv
         Hierarchical::Cutout => {
             let view = clusters.view();
             let image = view.to_color_image();
-            let runner = Runner::new(
-                RunnerConfig {
-                    diagonal: false,
-                    hierarchical: 64,
-                    batch_size: 25600,
-                    good_min_area: 0,
-                    good_max_area: (image.width * image.height) as usize,
-                    is_same_color_a: 0,
-                    is_same_color_b: 1,
-                    deepen_diff: 0,
-                    hollow_neighbours: 0,
-                    key_color,
-                    keying_action: KeyingAction::Discard,
-                },
-                image,
-            );
+            let runner = Runner::new(RunnerConfig {
+                diagonal: false,
+                hierarchical: 64,
+                batch_size: 25600,
+                good_min_area: 0,
+                good_max_area: (image.width * image.height) as usize,
+                is_same_color_a: 0,
+                is_same_color_b: 1,
+                deepen_diff: 0,
+                hollow_neighbours: 0,
+                key_color,
+                keying_action: KeyingAction::Discard,
+            }, image);
             clusters = runner.run();
-        }
+        },
     }
 
     let view = clusters.view();
@@ -174,18 +161,26 @@ fn color_image_to_svg(mut img: ColorImage, config: ConverterConfig) -> Result<Sv
             config.corner_threshold,
             config.length_threshold,
             config.max_iterations,
-            config.splice_threshold,
+            config.splice_threshold
         );
         svg.add_path(paths, cluster.residue_color());
     }
 
-    Ok(svg)
+    write_svg(svg, config.output_path)
 }
 
-fn binary_image_to_svg(img: ColorImage, config: ConverterConfig) -> Result<SvgFile, String> {
+fn binary_image_to_svg(config: ConverterConfig) -> Result<(), String> {
+
+    let (img, width, height);
+    match read_image(config.input_path) {
+        Ok(values) => {
+            img = values.0;
+            width = values.1;
+            height = values.2;
+        },
+        Err(msg) => return Err(msg),
+    }
     let img = img.to_binary_image(|x| x.r < 128);
-    let width = img.width;
-    let height = img.height;
 
     let clusters = img.to_clusters(false);
 
@@ -204,10 +199,10 @@ fn binary_image_to_svg(img: ColorImage, config: ConverterConfig) -> Result<SvgFi
         }
     }
 
-    Ok(svg)
+    write_svg(svg, config.output_path)
 }
 
-fn read_image(input_path: &Path) -> Result<ColorImage, String> {
+fn read_image(input_path: PathBuf) -> Result<(ColorImage, usize, usize), String> {
     let img = image::open(input_path);
     let img = match img {
         Ok(file) => file.to_rgba8(),
@@ -215,16 +210,12 @@ fn read_image(input_path: &Path) -> Result<ColorImage, String> {
     };
 
     let (width, height) = (img.width() as usize, img.height() as usize);
-    let img = ColorImage {
-        pixels: img.as_raw().to_vec(),
-        width,
-        height,
-    };
+    let img = ColorImage {pixels: img.as_raw().to_vec(), width, height};
 
-    Ok(img)
+    Ok((img, width, height))
 }
 
-fn write_svg(svg: SvgFile, output_path: &Path) -> Result<(), String> {
+fn write_svg(svg: SvgFile, output_path: PathBuf) -> Result<(), String> {
     let out_file = File::create(output_path);
     let mut out_file = match out_file {
         Ok(file) => file,
@@ -234,4 +225,4 @@ fn write_svg(svg: SvgFile, output_path: &Path) -> Result<(), String> {
     write!(&mut out_file, "{}", svg).expect("failed to write file.");
 
     Ok(())
-}
+}

cmdapp/src/lib.rs

@@ -1,4 +1,4 @@
-// Copyright 2023 Tsang Hao Fung. See the COPYRIGHT
+// Copyright 2020 Tsang Hao Fung. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -10,13 +10,12 @@
 
 mod config;
 mod converter;
+mod svg;
 #[cfg(feature = "python-binding")]
 mod python;
-mod svg;
 
 pub use config::*;
 pub use converter::*;
-#[cfg(feature = "python-binding")]
-pub use python::*;
 pub use svg::*;
-pub use visioncortex::ColorImage;
+#[cfg(feature = "python-binding")]
+pub use python::*;

cmdapp/src/main.rs

@@ -1,282 +1,14 @@
-mod config;
-mod converter;
-mod svg;
-
-use clap::{App, Arg};
-use config::{ColorMode, Config, Hierarchical, Preset};
-use std::path::PathBuf;
-use std::str::FromStr;
-use visioncortex::PathSimplifyMode;
-
-fn path_simplify_mode_from_str(s: &str) -> PathSimplifyMode {
-    match s {
-        "polygon" => PathSimplifyMode::Polygon,
-        "spline" => PathSimplifyMode::Spline,
-        "none" => PathSimplifyMode::None,
-        _ => panic!("unknown PathSimplifyMode {}", s),
-    }
-}
-
-pub fn config_from_args() -> (PathBuf, PathBuf, Config) {
-    let app = App::new("visioncortex VTracer ".to_owned() + env!("CARGO_PKG_VERSION"))
-        .about("A cmd app to convert images into vector graphics.");
-
-    let app = app.arg(
-        Arg::with_name("input")
-            .long("input")
-            .short("i")
-            .takes_value(true)
-            .help("Path to input raster image")
-            .required(true),
-    );
-
-    let app = app.arg(
-        Arg::with_name("output")
-            .long("output")
-            .short("o")
-            .takes_value(true)
-            .help("Path to output vector graphics")
-            .required(true),
-    );
-
-    let app = app.arg(
-        Arg::with_name("color_mode")
-            .long("colormode")
-            .takes_value(true)
-            .help("True color image `color` (default) or Binary image `bw`"),
-    );
-
-    let app = app.arg(
-        Arg::with_name("hierarchical")
-            .long("hierarchical")
-            .takes_value(true)
-            .help(
-                "Hierarchical clustering `stacked` (default) or non-stacked `cutout`. \
-            Only applies to color mode. ",
-            ),
-    );
-
-    let app = app.arg(
-        Arg::with_name("preset")
-            .long("preset")
-            .takes_value(true)
-            .help("Use one of the preset configs `bw`, `poster`, `photo`"),
-    );
-
-    let app = app.arg(
-        Arg::with_name("filter_speckle")
-            .long("filter_speckle")
-            .short("f")
-            .takes_value(true)
-            .help("Discard patches smaller than X px in size"),
-    );
-
-    let app = app.arg(
-        Arg::with_name("color_precision")
-            .long("color_precision")
-            .short("p")
-            .takes_value(true)
-            .help("Number of significant bits to use in an RGB channel"),
-    );
-
-    let app = app.arg(
-        Arg::with_name("gradient_step")
-            .long("gradient_step")
-            .short("g")
-            .takes_value(true)
-            .help("Color difference between gradient layers"),
-    );
-
-    let app = app.arg(
-        Arg::with_name("corner_threshold")
-            .long("corner_threshold")
-            .short("c")
-            .takes_value(true)
-            .help("Minimum momentary angle (degree) to be considered a corner"),
-    );
-
-    let app = app.arg(Arg::with_name("segment_length")
-        .long("segment_length")
-        .short("l")
-        .takes_value(true)
-        .help("Perform iterative subdivide smooth until all segments are shorter than this length"));
-
-    let app = app.arg(
-        Arg::with_name("splice_threshold")
-            .long("splice_threshold")
-            .short("s")
-            .takes_value(true)
-            .help("Minimum angle displacement (degree) to splice a spline"),
-    );
-
-    let app = app.arg(
-        Arg::with_name("mode")
-            .long("mode")
-            .short("m")
-            .takes_value(true)
-            .help("Curver fitting mode `pixel`, `polygon`, `spline`"),
-    );
-
-    let app = app.arg(
-        Arg::with_name("path_precision")
-            .long("path_precision")
-            .takes_value(true)
-            .help("Number of decimal places to use in path string"),
-    );
-
-    // Extract matches
-    let matches = app.get_matches();
-
-    let mut config = Config::default();
-    let input_path = matches
-        .value_of("input")
-        .expect("Input path is required, please specify it by --input or -i.");
-    let output_path = matches
-        .value_of("output")
-        .expect("Output path is required, please specify it by --output or -o.");
-
-    let input_path = PathBuf::from(input_path);
-    let output_path = PathBuf::from(output_path);
-
-    if let Some(value) = matches.value_of("preset") {
-        config = Config::from_preset(Preset::from_str(value).unwrap());
-    }
-
-    if let Some(value) = matches.value_of("color_mode") {
-        config.color_mode = ColorMode::from_str(if value.trim() == "bw" || value.trim() == "BW" {
-            "binary"
-        } else {
-            "color"
-        })
-        .unwrap()
-    }
-
-    if let Some(value) = matches.value_of("hierarchical") {
-        config.hierarchical = Hierarchical::from_str(value).unwrap()
-    }
-
-    if let Some(value) = matches.value_of("mode") {
-        let value = value.trim();
-        config.mode = path_simplify_mode_from_str(if value == "pixel" {
-            "none"
-        } else if value == "polygon" {
-            "polygon"
-        } else if value == "spline" {
-            "spline"
-        } else {
-            panic!("Parser Error: Curve fitting mode is invalid: {}", value);
-        });
-    }
-
-    if let Some(value) = matches.value_of("filter_speckle") {
-        if value.trim().parse::<usize>().is_ok() {
-            // is numeric
-            let value = value.trim().parse::<usize>().unwrap();
-            if value > 16 {
-                panic!("Out of Range Error: Filter speckle is invalid at {}. It must be within [0,16].", value);
-            }
-            config.filter_speckle = value;
-        } else {
-            panic!(
-                "Parser Error: Filter speckle is not a positive integer: {}.",
-                value
-            );
-        }
-    }
-
-    if let Some(value) = matches.value_of("color_precision") {
-        if value.trim().parse::<i32>().is_ok() {
-            // is numeric
-            let value = value.trim().parse::<i32>().unwrap();
-            if value < 1 || value > 8 {
-                panic!("Out of Range Error: Color precision is invalid at {}. It must be within [1,8].", value);
-            }
-            config.color_precision = value;
-        } else {
-            panic!(
-                "Parser Error: Color precision is not an integer: {}.",
-                value
-            );
-        }
-    }
-
-    if let Some(value) = matches.value_of("gradient_step") {
-        if value.trim().parse::<i32>().is_ok() {
-            // is numeric
-            let value = value.trim().parse::<i32>().unwrap();
-            if value < 0 || value > 255 {
-                panic!("Out of Range Error: Gradient step is invalid at {}. It must be within [0,255].", value);
-            }
-            config.layer_difference = value;
-        } else {
-            panic!("Parser Error: Gradient step is not an integer: {}.", value);
-        }
-    }
-
-    if let Some(value) = matches.value_of("corner_threshold") {
-        if value.trim().parse::<i32>().is_ok() {
-            // is numeric
-            let value = value.trim().parse::<i32>().unwrap();
-            if value < 0 || value > 180 {
-                panic!("Out of Range Error: Corner threshold is invalid at {}. It must be within [0,180].", value);
-            }
-            config.corner_threshold = value
-        } else {
-            panic!("Parser Error: Corner threshold is not numeric: {}.", value);
-        }
-    }
-
-    if let Some(value) = matches.value_of("segment_length") {
-        if value.trim().parse::<f64>().is_ok() {
-            // is numeric
-            let value = value.trim().parse::<f64>().unwrap();
-            if value < 3.5 || value > 10.0 {
-                panic!("Out of Range Error: Segment length is invalid at {}. It must be within [3.5,10].", value);
-            }
-            config.length_threshold = value;
-        } else {
-            panic!("Parser Error: Segment length is not numeric: {}.", value);
-        }
-    }
-
-    if let Some(value) = matches.value_of("splice_threshold") {
-        if value.trim().parse::<i32>().is_ok() {
-            // is numeric
-            let value = value.trim().parse::<i32>().unwrap();
-            if value < 0 || value > 180 {
-                panic!("Out of Range Error: Segment length is invalid at {}. It must be within [0,180].", value);
-            }
-            config.splice_threshold = value;
-        } else {
-            panic!("Parser Error: Segment length is not numeric: {}.", value);
-        }
-    }
-
-    if let Some(value) = matches.value_of("path_precision") {
-        if value.trim().parse::<u32>().is_ok() {
-            // is numeric
-            let value = value.trim().parse::<u32>().ok();
-            config.path_precision = value;
-        } else {
-            panic!(
-                "Parser Error: Path precision is not an unsigned integer: {}.",
-                value
-            );
-        }
-    }
-
-    (input_path, output_path, config)
-}
+use vtracer::{Config, convert_image_to_svg};
 
 fn main() {
-    let (input_path, output_path, config) = config_from_args();
-    let result = converter::convert_image_to_svg(&input_path, &output_path, config);
+    let config = Config::from_args();
+    let result = convert_image_to_svg(config);
     match result {
         Ok(()) => {
             println!("Conversion successful.");
-        }
+        },
         Err(msg) => {
             panic!("Conversion failed with error message: {}", msg);
         }
     }
-}
+}

cmdapp/src/python.rs

@@ -1,173 +1,28 @@
-use crate::*;
-use image::{io::Reader, ImageFormat};
-use pyo3::{exceptions::PyException, prelude::*};
-use std::io::{BufReader, Cursor};
-use std::path::PathBuf;
-use visioncortex::PathSimplifyMode;
+use pyo3::prelude::*;
+
+use visioncortex::{PathSimplifyMode};
+use super::converter::*;
 
 /// Python binding
 #[pyfunction]
-fn convert_image_to_svg_py(
-    image_path: &str,
-    out_path: &str,
-    colormode: Option<&str>,       // "color" or "binary"
-    hierarchical: Option<&str>,    // "stacked" or "cutout"
-    mode: Option<&str>,            // "polygon", "spline", "none"
-    filter_speckle: Option<usize>, // default: 4
-    color_precision: Option<i32>,  // default: 6
-    layer_difference: Option<i32>, // default: 16
-    corner_threshold: Option<i32>, // default: 60
-    length_threshold: Option<f64>, // in [3.5, 10] default: 4.0
-    max_iterations: Option<usize>, // default: 10
-    splice_threshold: Option<i32>, // default: 45
-    path_precision: Option<u32>,   // default: 8
-) -> PyResult<()> {
+fn convert_image_to_svg_py( image_path: &str, 
+                            out_path: &str,   
+                            colormode: Option<&str>,       // "color" or "binary"
+                            hierarchical: Option<&str>,    // "stacked" or "cutout"
+                            mode: Option<&str>,            // "polygon", "spline", "none"
+                            filter_speckle: Option<usize>, // default: 4
+                            color_precision: Option<i32>,  // default: 6
+                            layer_difference: Option<i32>, // default: 16
+                            corner_threshold: Option<i32>, // default: 60   
+                            length_threshold: Option<f64>, // in [3.5, 10] default: 4.0
+                            max_iterations: Option<usize>, // default: 10
+                            splice_threshold: Option<i32>, // default: 45
+                            path_precision: Option<u32>    // default: 8
+                        ) -> PyResult<()> {
     let input_path = PathBuf::from(image_path);
     let output_path = PathBuf::from(out_path);
 
-    let config = construct_config(
-        colormode,
-        hierarchical,
-        mode,
-        filter_speckle,
-        color_precision,
-        layer_difference,
-        corner_threshold,
-        length_threshold,
-        max_iterations,
-        splice_threshold,
-        path_precision,
-    );
-
-    convert_image_to_svg(&input_path, &output_path, config).unwrap();
-    Ok(())
-}
-
-#[pyfunction]
-fn convert_raw_image_to_svg(
-    img_bytes: Vec<u8>,
-    img_format: Option<&str>, // Format of the image (e.g. 'jpg', 'png'... A full list of supported formats can be found [here](https://docs.rs/image/latest/image/enum.ImageFormat.html)). If not provided, the image format will be guessed based on its contents.
-    colormode: Option<&str>,  // "color" or "binary"
-    hierarchical: Option<&str>, // "stacked" or "cutout"
-    mode: Option<&str>,       // "polygon", "spline", "none"
-    filter_speckle: Option<usize>, // default: 4
-    color_precision: Option<i32>, // default: 6
-    layer_difference: Option<i32>, // default: 16
-    corner_threshold: Option<i32>, // default: 60
-    length_threshold: Option<f64>, // in [3.5, 10] default: 4.0
-    max_iterations: Option<usize>, // default: 10
-    splice_threshold: Option<i32>, // default: 45
-    path_precision: Option<u32>, // default: 8
-) -> PyResult<String> {
-    let config = construct_config(
-        colormode,
-        hierarchical,
-        mode,
-        filter_speckle,
-        color_precision,
-        layer_difference,
-        corner_threshold,
-        length_threshold,
-        max_iterations,
-        splice_threshold,
-        path_precision,
-    );
-    let mut img_reader = Reader::new(BufReader::new(Cursor::new(img_bytes)));
-    let img_format = img_format.and_then(|ext_name| ImageFormat::from_extension(ext_name));
-    let img = match img_format {
-        Some(img_format) => {
-            img_reader.set_format(img_format);
-            img_reader.decode()
-        }
-        None => img_reader
-            .with_guessed_format()
-            .map_err(|_| PyException::new_err("Unrecognized image format. "))?
-            .decode(),
-    };
-    let img = match img {
-        Ok(img) => img.to_rgba8(),
-        Err(_) => return Err(PyException::new_err("Failed to decode img_bytes. ")),
-    };
-    let (width, height) = (img.width() as usize, img.height() as usize);
-    let img = ColorImage {
-        pixels: img.as_raw().to_vec(),
-        width,
-        height,
-    };
-    let svg =
-        convert(img, config).map_err(|_| PyException::new_err("Failed to convert the image. "))?;
-    Ok(format!("{}", svg))
-}
-
-#[pyfunction]
-fn convert_pixels_to_svg(
-    rgba_pixels: Vec<(u8, u8, u8, u8)>,
-    size: (usize, usize),
-    colormode: Option<&str>,       // "color" or "binary"
-    hierarchical: Option<&str>,    // "stacked" or "cutout"
-    mode: Option<&str>,            // "polygon", "spline", "none"
-    filter_speckle: Option<usize>, // default: 4
-    color_precision: Option<i32>,  // default: 6
-    layer_difference: Option<i32>, // default: 16
-    corner_threshold: Option<i32>, // default: 60
-    length_threshold: Option<f64>, // in [3.5, 10] default: 4.0
-    max_iterations: Option<usize>, // default: 10
-    splice_threshold: Option<i32>, // default: 45
-    path_precision: Option<u32>,   // default: 8
-) -> PyResult<String> {
-    let expected_pixel_count = size.0 * size.1;
-    if rgba_pixels.len() != expected_pixel_count {
-        return Err(PyException::new_err(format!(
-            "Length of rgba_pixels does not match given image size. Expected {} ({} * {}), got {}. ",
-            expected_pixel_count,
-            size.0,
-            size.1,
-            rgba_pixels.len()
-        )));
-    }
-    let config = construct_config(
-        colormode,
-        hierarchical,
-        mode,
-        filter_speckle,
-        color_precision,
-        layer_difference,
-        corner_threshold,
-        length_threshold,
-        max_iterations,
-        splice_threshold,
-        path_precision,
-    );
-    let mut flat_pixels: Vec<u8> = vec![];
-    for (r, g, b, a) in rgba_pixels {
-        flat_pixels.push(r);
-        flat_pixels.push(g);
-        flat_pixels.push(b);
-        flat_pixels.push(a);
-    }
-    let mut img = ColorImage::new();
-    img.pixels = flat_pixels;
-    (img.width, img.height) = size;
-
-    let svg =
-        convert(img, config).map_err(|_| PyException::new_err("Failed to convert the image. "))?;
-    Ok(format!("{}", svg))
-}
-
-fn construct_config(
-    colormode: Option<&str>,
-    hierarchical: Option<&str>,
-    mode: Option<&str>,
-    filter_speckle: Option<usize>,
-    color_precision: Option<i32>,
-    layer_difference: Option<i32>,
-    corner_threshold: Option<i32>,
-    length_threshold: Option<f64>,
-    max_iterations: Option<usize>,
-    splice_threshold: Option<i32>,
-    path_precision: Option<u32>,
-) -> Config {
-    // TODO: enforce color mode with an enum so that we only
+    // TODO: enforce color mode with an enum so that we only 
     // accept the strings 'color' or 'binary'
     let color_mode = match colormode.unwrap_or("color") {
         "color" => ColorMode::Color,
@@ -180,7 +35,7 @@ fn construct_config(
         "cutout" => Hierarchical::Cutout,
         _ => Hierarchical::Stacked,
     };
-
+    
     let mode = match mode.unwrap_or("spline") {
         "spline" => PathSimplifyMode::Spline,
         "polygon" => PathSimplifyMode::Polygon,
@@ -188,15 +43,17 @@ fn construct_config(
         _ => PathSimplifyMode::Spline,
     };
 
-    let filter_speckle = filter_speckle.unwrap_or(4);
-    let color_precision = color_precision.unwrap_or(6);
-    let layer_difference = layer_difference.unwrap_or(16);
-    let corner_threshold = corner_threshold.unwrap_or(60);
-    let length_threshold = length_threshold.unwrap_or(4.0);
-    let splice_threshold = splice_threshold.unwrap_or(45);
-    let max_iterations = max_iterations.unwrap_or(10);
+    let filter_speckle =    filter_speckle.unwrap_or(4);
+    let color_precision =   color_precision.unwrap_or(6);
+    let layer_difference =  layer_difference.unwrap_or(16);
+    let corner_threshold =  corner_threshold.unwrap_or(60);
+    let length_threshold =  length_threshold.unwrap_or(4.0);
+    let splice_threshold =  splice_threshold.unwrap_or(45);
+    let max_iterations =    max_iterations.unwrap_or(10);
 
-    Config {
+    let config = Config {
+        input_path,
+        output_path,
         color_mode,
         hierarchical,
         filter_speckle,
@@ -208,15 +65,17 @@ fn construct_config(
         max_iterations,
         splice_threshold,
         path_precision,
-        ..Default::default()
-    }
+        ..Default::default()                
+    };
+
+
+    convert_image_to_svg(config).unwrap();
+    Ok(())
 }
 
 /// A Python module implemented in Rust.
 #[pymodule]
 fn vtracer(_py: Python, m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(convert_image_to_svg_py, m)?)?;
-    m.add_function(wrap_pyfunction!(convert_raw_image_to_svg, m)?)?;
-    m.add_function(wrap_pyfunction!(convert_pixels_to_svg, m)?)?;
     Ok(())
-}
+}

cmdapp/src/svg.rs

@@ -1,7 +1,6 @@
 use std::fmt;
 use visioncortex::{Color, CompoundPath, PointF64};
 
-#[derive(Debug, Clone)]
 pub struct SvgFile {
     pub paths: Vec<SvgPath>,
     pub width: usize,
@@ -9,7 +8,6 @@ pub struct SvgFile {
     pub path_precision: Option<u32>,
 }
 
-#[derive(Debug, Clone)]
 pub struct SvgPath {
     pub path: CompoundPath,
     pub color: Color,
@@ -26,27 +24,24 @@ impl SvgFile {
     }
 
     pub fn add_path(&mut self, path: CompoundPath, color: Color) {
-        self.paths.push(SvgPath { path, color })
+        self.paths.push(SvgPath {
+            path,
+            color,
+        })
     }
 }
 
 impl fmt::Display for SvgFile {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         writeln!(f, r#"<?xml version="1.0" encoding="UTF-8"?>"#)?;
-        writeln!(
-            f,
-            r#"<!-- Generator: visioncortex VTracer {} -->"#,
-            env!("CARGO_PKG_VERSION")
-        )?;
-        writeln!(
-            f,
+        writeln!(f,
             r#"<svg version="1.1" xmlns="http://www.w3.org/2000/svg" width="{}" height="{}">"#,
             self.width, self.height
         )?;
 
         for path in &self.paths {
             path.fmt_with_precision(f, self.path_precision)?;
-        }
+        };
 
         writeln!(f, "</svg>")
     }
@@ -60,16 +55,11 @@ impl fmt::Display for SvgPath {
 
 impl SvgPath {
     fn fmt_with_precision(&self, f: &mut fmt::Formatter, precision: Option<u32>) -> fmt::Result {
-        let (string, offset) = self
-            .path
-            .to_svg_string(true, PointF64::default(), precision);
+        let (string, offset) = self.path.to_svg_string(true, PointF64::default(), precision);
         writeln!(
-            f,
-            "<path d=\"{}\" fill=\"{}\" transform=\"translate({},{})\"/>",
-            string,
-            self.color.to_hex_string(),
-            offset.x,
-            offset.y
+            f, "<path d=\"{}\" fill=\"{}\" transform=\"translate({},{})\"/>",
+            string, self.color.to_hex_string(),
+            offset.x, offset.y
         )
     }
-}
+}

cmdapp/vtracer/README.md

@@ -52,17 +52,7 @@ vtracer.convert_image_to_svg_py(inp, out)
 # Single-color example. Good for line art, and much faster than full color:
 vtracer.convert_image_to_svg_py(inp, out, colormode='binary')
 
-# Convert from raw image bytes
-input_img_bytes: bytes = get_bytes() # e.g. reading bytes from a file or a HTTP request body
-svg_str: str = vtracer.convert_raw_image_to_svg(input_img_bytes, img_format='jpg')
-
-# Convert from RGBA image pixels
-from PIL import Image
-img = Image.open(input_path).convert('RGBA')
-pixels: list[tuple[int, int, int, int]] = list(img.getdata())
-svg_str: str = vtracer.convert_pixels_to_svg(pixels, img.size)
-
-# All the bells & whistles, also applicable to convert_raw_image_to_svg and convert_pixels_to_svg. 
+# All the bells & whistles
 vtracer.convert_image_to_svg_py(inp,
                                 out,
                                 colormode = 'color',        # ["color"] or "binary"

cmdapp/vtracer/__init__.py

@@ -1,2 +1 @@
-from .vtracer import (convert_image_to_svg_py, convert_pixels_to_svg,
-                      convert_raw_image_to_svg)
+from .vtracer import convert_image_to_svg_py

cmdapp/vtracer/vtracer.pyi

@@ -15,35 +15,3 @@ def convert_image_to_svg_py(image_path: str,
                             path_precision: Optional[int] = None,   # default: 8
                         ) -> None:
     ...
-
-def convert_raw_image_to_svg(img_bytes: bytes,
-                            img_format: Optional[str] = None,       # Format of the image (e.g. 'jpg', 'png'... A full list of supported formats can be found [here](https://docs.rs/image/latest/image/enum.ImageFormat.html)). If not provided, the image format will be guessed based on its contents. 
-                            colormode: Optional[str] = None,        # ["color"] or "binary"
-                            hierarchical: Optional[str] = None,     # ["stacked"] or "cutout"
-                            mode: Optional[str] = None,             # ["spline"], "polygon", "none"
-                            filter_speckle: Optional[int] = None,   # default: 4
-                            color_precision: Optional[int] = None,  # default: 6
-                            layer_difference: Optional[int] = None, # default: 16
-                            corner_threshold: Optional[int] = None, # default: 60   
-                            length_threshold: Optional[float] = None, # in [3.5, 10] default: 4.0
-                            max_iterations: Optional[int] = None,   # default: 10
-                            splice_threshold: Optional[int] = None, # default: 45
-                            path_precision: Optional[int] = None,   # default: 8
-                        ) -> str:
-    ...
-
-def convert_pixels_to_svg(rgba_pixels: list[tuple[int, int, int, int]],
-                            size: tuple[int, int],
-                            colormode: Optional[str] = None,        # ["color"] or "binary"
-                            hierarchical: Optional[str] = None,     # ["stacked"] or "cutout"
-                            mode: Optional[str] = None,             # ["spline"], "polygon", "none"
-                            filter_speckle: Optional[int] = None,   # default: 4
-                            color_precision: Optional[int] = None,  # default: 6
-                            layer_difference: Optional[int] = None, # default: 16
-                            corner_threshold: Optional[int] = None, # default: 60   
-                            length_threshold: Optional[float] = None, # in [3.5, 10] default: 4.0
-                            max_iterations: Optional[int] = None,   # default: 10
-                            splice_threshold: Optional[int] = None, # default: 45
-                            path_precision: Optional[int] = None,   # default: 8
-                        ) -> str:
-    ...

docs/images/filestar-logo.svg

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 19.2.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 1783.4 441.4" style="enable-background:new 0 0 1783.4 441.4;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#A1FCFE;}
+	.st1{fill:#010357;}
+</style>
+<rect class="st0" width="1783.4" height="441.4"/>
+<g>
+	<path class="st1" d="M61.4,393.2V73.8H250V113H109v100.4h124.2v39.7H109v140.1L61.4,393.2L61.4,393.2z"/>
+	<path class="st1" d="M280,393.2V159.7h45.3v233.5L280,393.2L280,393.2z M330.9,92.4c0-15.5-12.5-28-28-28s-28,12.5-28,28
+		s12.5,28,28,28S330.9,107.9,330.9,92.4z"/>
+	<path class="st1" d="M383.5,338.6V57.9h45.3v278.8c0,21,3.7,26.1,18.7,26.1c6.1,0,11.7-0.5,16.8-1.4v30.4
+		c-9.8,2.8-20.1,4.2-29.9,4.2C400.3,396,383.5,376.9,383.5,338.6z"/>
+	<path class="st1" d="M480.6,275.5c0-78.5,41.6-121.4,110.2-121.4c31.3,0,55.6,9.8,72.9,29.9c17.3,19.6,26.2,45.3,26.2,77.5
+		c0,7-0.5,14.9-1.9,24.3H525.4c0.9,50.9,22.4,76.6,64.4,76.6c31.8,0,53.2-14.5,53.2-42H687c0,48.6-39.7,77.5-97.6,77.5
+		C521.7,397.9,480.6,357.3,480.6,275.5z M645,251.7c-0.9-41.6-19.6-62.1-55.6-62.1c-39.7,0-59.8,24.3-63.5,62.1H645z"/>
+	<path class="st1" d="M720.7,323.2h44.8c1.9,28.5,18.7,38.8,51.8,38.8c28.5,0,46.7-15,46.7-35c0-20.6-16.8-28.5-48.1-36l-13.1-2.8
+		l-14.5-3.7l-12.6-4.2c-6.1-1.9-10.7-3.3-13.1-4.7c-5.1-3.3-17.3-8.9-21.5-14.5c-7.5-8.9-15.4-21.5-14-38.8c0-21,8.4-37.8,25.2-50
+		c17.3-12.1,37.8-18.2,62.1-18.2c55.6,0,91.5,22.4,91.5,72.4h-43c-0.5-26.6-16.8-36.4-49-36.4c-24.3,0-40.6,11.2-40.6,31.3
+		c0,18.7,15.9,25.7,49,33.6l5.6,1.4c10.3,2.3,18.2,4.7,23.3,6.1c5.1,1.4,12.1,4.2,21,8.4c23.8,10.3,34.6,25.7,36.9,56
+		c0,43.4-37.8,71-92.5,71C754.8,397.9,720.7,371.7,720.7,323.2z"/>
+	<path class="st1" d="M964,336.7V192.4h-39.2v-32.7h39.7V94.3h44.8v65.4h64v32.7h-64v143.4c0,17.3,8.9,25.7,26.2,25.7
+		c14.5,0,28-1.9,39.7-5.1v34.6c-13.6,4.2-28,6.1-43.4,6.1C986.9,397,964,375.5,964,336.7z"/>
+	<path class="st1" d="M1095.3,325.5c0-44.8,35-69.6,93.4-69.6h58.4v-20.6c0-28.5-16.8-45.8-50-45.8c-35.5,0-51.8,16.8-51.8,41.6
+		h-43.4c0-44.8,33.2-77.1,95.3-77.1c61.2,0,95.7,30.4,95.7,83.1v92.5c0,26.1,3.7,32.2,17.3,33.6h6.5v29.4
+		c-4.7,1.4-11.7,2.3-21.5,2.3c-26.6,0-41.6-15.9-43.4-41.6c-8.9,23.8-36.4,44.4-74.3,44.4C1127.5,397.9,1095.3,368.5,1095.3,325.5z
+		 M1247.1,297.5v-9.3h-58.4c-32.2,0-48.6,12.6-48.6,37.4c0,22.9,14,36.9,41.6,36.9C1222.3,362.4,1247.1,334.4,1247.1,297.5z"/>
+	<path class="st1" d="M1351.7,395.1V161.6h43.9l0.9,36.4h0.9c11.7-24.8,34.1-40.6,62.1-40.6c8.4,0,15.9,0.9,22.9,3.3v38.8
+		c-7.5-1.4-15.9-1.9-25.7-1.9c-33.2,0-59.3,28-59.3,72.9v124.7H1351.7z"/>
+	<g>
+		<g>
+			<rect x="1549" y="146.5" transform="matrix(0.866 -0.5 0.5 0.866 137.8024 841.2704)" class="st1" width="179.4" height="34"/>
+		</g>
+		<g>
+			<rect x="1621.7" y="73.8" transform="matrix(0.5 -0.866 0.866 0.5 677.7373 1500.9166)" class="st1" width="34" height="179.4"/>
+		</g>
+		<g>
+			<rect x="1621.7" y="73.8" class="st1" width="34" height="179.4"/>
+		</g>
+	</g>
+</g>
+</svg>

webapp/Cargo.toml

@@ -22,7 +22,7 @@ console_log = { version = "0.2", features = ["color"] }
 wasm-bindgen = { version = "0.2", features = ["serde-serialize"]  }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-visioncortex = "0.8.1"
+visioncortex = "0.6.0"
 
 # The `console_error_panic_hook` crate provides better debugging of panics by
 # logging them with `console.error`. This is great for development, but requires

webapp/app/index.js

@@ -35,11 +35,7 @@ document.addEventListener('paste', function (e) {
 
 // Download as SVG
 document.getElementById('export').addEventListener('click', function (e) {
-    const blob = new Blob([
-        `<?xml version="1.0" encoding="UTF-8"?>\n`,
-        `<!-- Generator: visioncortex VTracer -->\n`,
-        new XMLSerializer().serializeToString(svg)
-    ], {type: 'octet/stream'}),
+    const blob = new Blob([new XMLSerializer().serializeToString(svg)], {type: 'octet/stream'}),
     url = window.URL.createObjectURL(blob);
 
     this.href = url;
@@ -448,7 +444,7 @@ class ConverterRunner {
         this.converter.init();
         this.stopped = false;
         if (clustering_mode == 'binary') {
-            svg.style.background = '#fff';
+            svg.style.background = '#000';
             canvas.style.display = 'none';
         } else {
             svg.style.background = '';

webapp/src/conversion/binary_image.rs

@@ -77,7 +77,7 @@ impl BinaryImageConverter {
                     self.params.max_iterations,
                     self.params.splice_threshold
                 );
-                let color = Color::color(&ColorName::Black);
+                let color = Color::color(&ColorName::White);
                 self.svg.prepend_path(
                     &paths,
                     &color,

webapp/src/conversion/color_image.rs

@@ -1,6 +1,6 @@
 use wasm_bindgen::prelude::*;
-use visioncortex::{Color, ColorImage, PathSimplifyMode};
-use visioncortex::color_clusters::{Clusters, Runner, RunnerConfig, HIERARCHICAL_MAX, IncrementalBuilder, KeyingAction};
+use visioncortex::PathSimplifyMode;
+use visioncortex::color_clusters::{IncrementalBuilder, Clusters, Runner, RunnerConfig, HIERARCHICAL_MAX};
 
 use crate::canvas::*;
 use crate::svg::*;
@@ -8,8 +8,6 @@ use crate::svg::*;
 use serde::Deserialize;
 use super::util;
 
-const KEYING_THRESHOLD: f32 = 0.2;
-
 #[derive(Debug, Deserialize)]
 pub struct ColorImageConverterParams {
     pub canvas_id: String,
@@ -69,26 +67,7 @@ impl ColorImageConverter {
     pub fn init(&mut self) {
         let width = self.canvas.width() as u32;
         let height = self.canvas.height() as u32;
-        let mut image = self.canvas.get_image_data_as_color_image(0, 0, width, height);
-
-        let key_color = if Self::should_key_image(&image) {
-            if let Ok(key_color) = Self::find_unused_color_in_image(&image) {
-                for y in 0..height as usize {
-                    for x in 0..width as usize {
-                        if image.get_pixel(x, y).a == 0 {
-                            image.set_pixel(x, y, &key_color);
-                        }
-                    }
-                }
-                key_color
-            } else {
-                Color::default()
-            }
-        } else {
-            // The default color is all zeroes, which is treated by visioncortex as a special value meaning no keying will be applied.
-            Color::default()
-        };
-
+        let image = self.canvas.get_image_data_as_color_image(0, 0, width, height);
         let runner = Runner::new(RunnerConfig {
             diagonal: self.params.layer_difference == 0,
             hierarchical: HIERARCHICAL_MAX,
@@ -99,12 +78,6 @@ impl ColorImageConverter {
             is_same_color_b: 1,
             deepen_diff: self.params.layer_difference,
             hollow_neighbours: 1,
-            key_color,
-            keying_action: if self.params.hierarchical == "cutout" {
-                KeyingAction::Keep
-            } else {
-                KeyingAction::Discard
-            },
         }, image);
         self.stage = Stage::Clustering(runner.start());
     }
@@ -135,8 +108,6 @@ impl ColorImageConverter {
                                 is_same_color_b: 1,
                                 deepen_diff: 0,
                                 hollow_neighbours: 0,
-                                key_color: Default::default(),
-                                keying_action: KeyingAction::Discard,
                             }, image);
                             self.stage = Stage::Reclustering(runner.start());
                         },
@@ -196,56 +167,4 @@ impl ColorImageConverter {
         }) as i32
     }
 
-    fn color_exists_in_image(img: &ColorImage, color: Color) -> bool {
-        for y in 0..img.height {
-            for x in 0..img.width {
-                let pixel_color = img.get_pixel(x, y);
-                if pixel_color.r == color.r && pixel_color.g == color.g && pixel_color.b == color.b {
-                    return true
-                }
-            }
-        }
-        false
-    }
-    
-    fn find_unused_color_in_image(img: &ColorImage) -> Result<Color, String> {
-        let special_colors = IntoIterator::into_iter([
-            Color::new(255, 0,   0),
-            Color::new(0,   255, 0),
-            Color::new(0,   0,   255),
-            Color::new(255, 255, 0),
-            Color::new(0,   255, 255),
-            Color::new(255, 0,   255),
-            Color::new(128, 128, 128),
-        ]);
-        for color in special_colors {
-            if !Self::color_exists_in_image(img, color) {
-                return Ok(color);
-            }
-        }
-        Err(String::from("unable to find unused color in image to use as key"))
-    }
-    
-    fn should_key_image(img: &ColorImage) -> bool {
-        if img.width == 0 || img.height == 0 {
-            return false;
-        }
-    
-        // Check for transparency at several scanlines
-        let threshold = ((img.width * 2) as f32 * KEYING_THRESHOLD) as usize;
-        let mut num_transparent_pixels = 0;
-        let y_positions = [0, img.height / 4, img.height / 2, 3 * img.height / 4, img.height - 1];
-        for y in y_positions {
-            for x in 0..img.width {
-                if img.get_pixel(x, y).a == 0 {
-                    num_transparent_pixels += 1;
-                }
-                if num_transparent_pixels >= threshold {
-                    return true;
-                }
-            }
-        }
-    
-        false
-    }
 }

webapp/src/conversion/mod.rs

@@ -1,3 +1,6 @@
 mod binary_image;
 mod color_image;
 mod util;
+
+pub use binary_image::*;
+pub use color_image::*;