pixlab VS ANTLR

In this blog post, I will show you a live demo and how you can implement this in your Nextjs/React app using PixLab's powerful computer vision APIs.

PixLab (https://pixlab.io) & FACEIO (https://faceio.net) | Full-or-part-time | Remote | Computer Vision / Full stack Engineers |

PixLab, a leading provider of Machine Vision, Face Recognition & Media Processing APIs is looking for:

* Embedded C & Computer Vision engineer(s) to work on the SOD (https://sod.pixlab.io), embedded computer vision library.

* Senior Python engineer with proficiency in PyTorch to work on FACEIO (https://faceio.net), our facial authentication web framework for web sites & apps.

* C++ developer with ML expertise to work on the port of Tiny-Dream (https://pixlab.io/tiny-dream), our embedded Stable Diffusion C++ library from ncnn to ggml.

* React/Vue JS Web developer(s) with expertise in fabric.js to work on a brand new, web based photo editing software backed by generative AI.

Reach out to Vincent via contact AT pixlab.io with your resume if interested.

We are pleased to introduce FACEIO, a product developed from scratch here at PixLab in the past few years. We look forward to hear your thoughts about this...

Hi HN,

We are the core developers behind FACEIO (https://faceio.net), a product developed from scratch here at PixLab (https://pixlab.io) in the past few years.

FACEIO is a cross-browser, Cloud & On-Premise deployable, facial authentication framework, with a client-side JavaScript library (fio.js) that integrates seamlessly with any website or web application desiring to offer secure facial recognition experience to their users.

Put it simply, FACEIO is the easiest way to add passwordless authentication to web based applications. Simply implement fio.js on your website, and you will be able to instantly authenticate your existing users, and enroll new ones via Face Recognition using their computer Webcam or smartphone frontal camera on their favorite browser.

FACEIO works with regular Webcams or smartphones frontal camera on all modern browsers, does not require biometric sensors to be available on the client side, and works seemingly with all websites and web applications regardless of the underlying front-end JavaScript framework or server-side language or technology.

Implementing FACEIO is straightforward. Before so, you need to create a new application first on the FACEIO Console (https://console.faceio.net), and link this resource to your website or web application. The checklist below highlights the steps to follow for a smooth integration of fio.js on your site:

1. Create a new FACEIO application first: Follow the Application Wizard on the FACEIO Console to create your first application and link it to your website or web application.

2. Select a Facial Recognition Engine: Review Security & Privacy settings, Cloud or On-Premise deployment and customize the Widget look & feel, all done via the Application Wizard (https://console.faceio.net).

3. Add the fio.js library to your Website: Implement fio.js (https://faceio.net/getting-started), our facial recognition library on your website before rolling facial authentication to your audience...

4. Enroll & Authenticate your first used via the enroll() & authenticate() methods respectively, the only two exported methods from the fio.js library.

The details:

Each enrolled user on your website represented by its feature vector (biometrics hashes, mapped by the selected facial recognition engine), alongside with his Unique Facial ID (https://faceio.net/facialid), as well as, any metadata you have already linked to a particular user, is stored in a sand-boxed binary index called Application in the FACEIO jargon. Think of FACEIO Application as an isolated container of your users' data. Only your application with its encryption key can gain access to this index (features vectors & metadata). You can retrieve your encryption key via the Application Manager on the FACEIO Console.

You can create a new application via the FACEIO Console in a matter of minutes. This is easily done thanks to the Application Wizard. The wizard should automate the creation process for you. Usually, this involve inputting an application name, selecting a facial Recognition engine, reviewing security options, customizing the Widget layout, and so forth.

We have baked privacy and security directly into our infrastructure. We collect and store the minimum amount of personal information needed to authenticate users, and we back that up with intelligence-backed security monitoring. The underlying Facial Recognition Engines that FACEIO rely on such as PixLab Insight or AWS Rekognition only stores hash signatures of your facial features, a stream of meaningless floating point numbers anonymously, after your full explicit consent, and/or until you submits a removal request.

FACEIO itself (the service) including this Website, the fio.js facial authentication library, the Embedded Widget, the Rest API, the Console) does not store or handle biometrics nor even know anything about them. It is the responsibility of the selected facial recognition engine by the application owner (eg website or web application you use) to choose a cloud storage region or opt for on-premises deployment for storing biometrics hash.

Finally, The following tutorials, and guides should help you get started with FACEIO:

1.Getting Started Tutorial: Learn the fundamentals. Your first steps with FACEIO - https://faceio.net/getting-started.

2.Integration Guide: Learn how to implement fio.js, our facial recognition library on your website before rolling facial authentication to your audience - https://faceio.net/integration-guide

3.Developer Center: Code samples, documentation, support channels, and all the resources you need to implement FACEIO on your website - https://faceio.net/dev-guides

4. Trust Center: Learn how we handle your data securely and in compliance with privacy and legal requirements. - https://faceio.net/trust-center | https://faceio.net/apps-best-practice

import 'package:flutter/material.dart'; import 'package:dio/dio.dart'; void main() { runApp( const MaterialApp( home: FaceBlurPage(), ), ); } class FaceBlurPage extends StatefulWidget { const FaceBlurPage({super.key}); @override State createState() => _FaceBlurPageState(); } class _FaceBlurPageState extends State { String pixlabkey = "74389de25cb37a10adf615e8a79c8da4"; String imagelink = "https://pixlab.io/images/m3.jpg"; String? blurImagelink; // Instentiating Dio var dio = Dio(); // Detect faces using pixlab API Future detectFaces(String image) async { return dio.get( "https://api.pixlab.io/facedetect", queryParameters: { "img": image, "key": pixlabkey, }, ); } // Blurring faces using facial coordinates Future blurface(String image, List coordinates) async { return await dio.post( "https://api.pixlab.io/mogrify", data: { "img": image, "key": pixlabkey, "cord": coordinates, }, options: Options(contentType: "application/json"), ); } @override Widget build(BuildContext context) { return Scaffold( appBar: AppBar( title: const Text("Face Blur Example"), ), body: Column( children: [ Image.network(imagelink), blurImagelink != null ? Image.network(blurImagelink!) : const Text("No image provided"), ], ), floatingActionButton: FloatingActionButton( onPressed: () async { Response faces = await detectFaces(imagelink); Response blurfaceImageResponse = await blurface(imagelink, faces.data["faces"]); setState(() { blurImagelink = blurfaceImageResponse.data["ssl_link"]; }); }, child: const Icon(Icons.auto_mode_rounded), ), ); } }

Hi HN,

My team and I, developed PixLab as a independent product (kind of subsidiary now) back in 2017 for our parent company (Symisc Systems). Since then, the platform has grown to over 130 Computer Vision API endpoints[1], and hundreds of API consumers. We currently serve over 29 million API requests each month. We’ve bootstrapped PixLab entirely ourselves. Our goal is to build a product that developers enjoy using.

PixLab is a unified API platform that integrates vision, storage, prediction, annotation, and media processing. We offer cloud Rest APIs (https://pixlab.io/api), on-premises deployment (https://pixlab.io/on-premises), and embedded C/C++ SDK (https://sod.pixlab.io). Our API offering includes Face Detection|Blur|Recognition, Content Moderation, NSFW Classification, Passports/ID Scan, Gender/Age detection, Image Tagging, and many others[1]. We’d love you to try PixLab and let us know what you think. You can find out some production ready code samples at the samples page[2] and the Github repository[3]

[1]: https://pixlab.io/cmdls

[2]: https://pixlab.io/examples

[3]: https://github.com/symisc/pixlab

antlr https://github.com/antlr/antlr4

Download the ANTLR jar from https://www.antlr.org/download/antlr-4.9.2-complete.jar Add the ANTLR jar to your project's classpath. Install the ANTLR Kotlin target by following the instructions at https://github.com/antlr/antlr4/blob/master/doc/targets/Kotlin.md Next, you'll need a Perl grammar file for ANTLR:

Write a context-free grammar for it, commonly written in Backus Naur Form, and use that to write a parser. There are tools named "parser generators" like antlr4 that can automatically convert a BNF grammar into a parser.

Tutorial on using it in Java: https://www.baeldung.com/java-antlr Github project itself with docs and examples: https://github.com/antlr/antlr4

Depending on how complex your expressions are, you might consider using something like antlr and writing your own parser for it. Setting up something to handle math and string operations wouldn’t be very hard and then you can control the syntax however you like. You can use a visitor and visit each node in the syntax tree and return the result of each sub-expression.

> ...than it would be to learn the exact syntax and quirks and possibly bugs of someone else's implementation...

Yup. Also, having deep knowledge of the language is required.

SQLite's grammar is neat. Creating a compatible parser would make a fun project. Here's a pretty good example: https://github.com/bkiers/sqlite-parser (Actual ANTLR 4 grammar: https://github.com/bkiers/sqlite-parser/blob/master/src/main... )

Postgres, which tries to be compliant with the latest standards, however...

SQL-2016 is a beast. Not to mention all the dialects.

I'm updating my personal (soon to be FOSS) grammar from ANTLR 3 LL(k) to ANTLR 4 ALL().

I've long had a working knowledge of SQL-92, with some SQL-1999 (eg common table expressions).

But the new structures and extensions are a bit overwhelming.

Fortunately, ANTLR project has ~dozen FOSS grammars to learn from. https://github.com/antlr/grammars-v4/tree/master/sql

They mostly mechanically translate BNFs to LL(k) with some ALL(). Meaning few take advantage of left-recursion. https://github.com/antlr/antlr4/blob/master/doc/left-recursi...

Honestly, I struggled to understand these grammars. Plus, not being conversant with the SQL-2016 was a huge impediment. Just finding a succinct corbis of test cases was a huge hurdle for me.

Fortunately, the H2 Database project is a great resource. https://github.com/h2database/h2database/tree/master/h2/src/...

Now for the exciting conclusion...

My ANTLR grammar which passes all of H2's tests looks nothing like any of the official or product specific BNFs.

Further, I found discrepancy between the product specific BNFs and their implementations.

So a lot of trial & error is required for a "real world" parser. Which would explain why the professional SQL parsing tools charge money.

I still think creating a parser for SQLite is a great project.

can be used to parse

I already posted here about a project, but I could also use help on Mantle. It's a new command framework powered by ANTLR, if that's something you're interested in.

ive been tryng to work with antlr4 and go but it seems that i cant import the runtime, it says that the antlr runtime isnt in the gopath but ive already done go get github.com/antlr/antlr4/runtime/antlr4 and i dont know what to do now, im on windows if anyone knows what to do it would be very helpful. thanks already