saidimu apale saidimu

Using Python 3 + Google Cloud Vision API's OCR to extract text from photos and scanned documents

Just a quickie test in Python 3 (using Requests) to see if Google Cloud Vision can be used to effectively OCR a scanned data table and preserve its structure, in the way that products such as ABBYY FineReader can OCR an image and provide Excel-ready output.

The short answer: No. While Cloud Vision provides bounding polygon coordinates in its output, it doesn't provide it at the word or region level, which would be needed to then calculate the data delimiters.

On the other hand, the OCR quality is pretty good, if you just need to identify text anywhere in an image, without regards to its physical coordinates. I've included two examples:

####### 1. A low-resolution photo of road signs

2015-01-29 Unofficial Relay FAQ

Compilation of questions and answers about Relay from React.js Conf.

Disclaimer: I work on Relay at Facebook. Relay is a complex system on which we're iterating aggressively. I'll do my best here to provide accurate, useful answers, but the details are subject to change. I may also be wrong. Feedback and additional questions are welcome.

What is Relay?

Relay is a new framework from Facebook that provides data-fetching functionality for React applications. It was announced at React.js Conf (January 2015).

ANNOUNCEMENT

I have moved this over to the Tech Interview Cheat Sheet Repo and has been expanded and even has code challenges you can run and practice against!

\

Most developers would agree that, all other things being equal, a synchronous program is easier to work with than an asynchronous one. The logic for this is pretty clear: one flow of execution is easier for the human mind to simulate than n concurrent flows.

After doing two small projects in node.js (one of which is here -- ready for the blinding flurry of criticism), there's one question that I can't shake: if asynchronicity is an optimization (that is, a complexity introduced for the sake of performance), why would people, a priori, turn to a framework that imposes it for everything? If asynchronous code is harder to reason about, why would we elect to live in a world where it is the default?

It could be argued pretty well that the browser is a domain that inherently lends itself to an async model, but I'd be very curious to hear a defense of "async-first" thinking for problems that are typically solved on the server-side. When working with node, I've noticed

Installing CartoDB on Ubuntu Server 12.04

Get CartoDB Rails application source

sudo apt-get update

sudo apt-get install git

cd ~

git clone --recursive https://github.com/CartoDB/cartodb20.git

	const React = require('react');
	const _ = require('lodash');

	var model = new falcor.Model({
	cache: {
	movies: [
	{
	title: "Daredevil",
	plot: "Marvel lol",
	year: "2015-",

	// Reloading modules from the repl in Node.js
	// Benjamin Gleitzman ([email protected])
	//
	// Inspired by Ben Barkay
	// http://stackoverflow.com/a/14801711/305414
	//
	// Usage: `node reload.js`
	// You can load the module as usual
	// var mymodule = require('./mymodule')
	// And the reload it when needed

	#!/usr/bin/env node

	var cordova_util = require('cordova/src/util');
	var projectRoot = cordova_util.isCordova(process.cwd());
	var projectXml = cordova_util.projectConfig(projectRoot);
	var projectConfig = new cordova_util.config_parser(projectXml);
	projectConfig.name();

	var fs = require ('fs');

	begin;

	create table user_ratings (
	id serial primary key,
	user_id integer not null,
	rating integer not null check (rating >= 0 and rating <= 5),
	ratable_id integer not null
	);

	create function random_int(max integer) returns integer as $$