facer 0.0.3

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+gemspec
+gem 'multipart-post'

data/README

@@ -0,0 +1,41 @@
+This Gem is a very alpha version and is provided as is without any warranty.
+
+I coded it as a convenient and easy interface to face.com's API for a project I'm working on and I must prepone some assumption on using it:
+
+	- you are a brave
+	- you will send images with only ONE recognizable face at time
+	- you expect some errors and bugs and have the bravery and patience to fix them
+
+If those requirements are met, go on and use it. If not stop reading and trash the gem...
+
+If you are reading this you are brave (or crazy).
+
+A little example of usage:
+
+linkr=Facer::Linker.new("yourapp","yourkey","yoursecret")
+puts linkr.account.private_namespaces?.inspect
+puts linkr.account.limits?.inspect
+
+trainSet={
+  "vanessa_paradis" => [
+    "http://www.superiorpics.com/hs/vanessa_paradis/main1.jpg",
+    "http://nymag.com/daily/fashion/14_paradis_lgl.jpg",
+    "http://imstars.aufeminin.com/stars/fan/vanessa-paradis/vanessa-paradis-20060208-107457.jpg",
+    "http://www.realbeauty.com/cm/realbeauty/images/NF/rby-hair-vanessa-paradis-5-de.jpg",
+    "http://www.wallpaperweb.org/wallpaper/babes/1280x960/vanessa_paradis_20070722_0171_1280x960.jpg",
+    "http://chansons-fle.wikispaces.com/file/view/vanessa_paradis_reference.jpg/59524266/vanessa_paradis_reference.jpg"
+  ]
+}
+
+trainSet.each_pair do |key,value|
+  succ= linkr.faces.associate_multi(value,key,"yournamespace").inspect
+  puts "Associating #{key}: #{succ}"
+end
+
+puts linkr.faces.train_all("clinik").inspect
+
+puts linkr.faces.recognize("http://static1.purepeople.com/articles/7/17/12/7/@/85769-vanessa-paradis-et-johnny-depp-637x0-1.jpg","yournamespace").inspect
+puts linkr.faces.recognize("http://howzar.com/Galleries/Vanessa%20Paradis/vanessa-paradis-32.jpg","yournamespace").inspect
+puts linkr.faces.recognize("http://pictures.directnews.co.uk/liveimages/Old+man+smiling_1500_19112072_0_0_7006461_300.jpg","yournamespace").inspect
+
+Stefano Valicchia (stefano.valicchia@gmail.com)

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/lib/facer'

data/lib/facer.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << './lib/facer'
+require 'rubygems'
+gem 'multipart-post'
+
+require "net/http"
+require "net/http/post/multipart"
+require 'mime/types'
+require "uri"
+require "json"
+
+require "linker"
+require "namespace"
+require "account"
+require "faces"
+
+# This class manage basilar operations on face.com.
+# It's very alpha so you will find a very basical subset
+# to use face.com services
+# Author::    Stefano Valicchia  (mailto:stefano.valicchiagmail.com)
+# Copyright:: Copyright (c) 2002 Giano
+# License::   Distributes under the same terms as Ruby
+module Facer
+  VERSION = "0.0.3"
+end

data/lib/facer/account.rb

@@ -0,0 +1,54 @@
+module Facer
+  # Base class to store security informations and obtain infos on the account
+  class Account
+    attr_reader :applicationName
+    attr_reader :apiKey
+    attr_reader :apiSecret
+    
+    # Initialize the class passing a convenient linker reference
+    def initialize(linker, app_name,api_key,api_secret)
+      @linker=linker
+      @applicationName=applicationName
+      @apiKey=key
+      @apiSecret=secret
+    end
+    
+    # Obtain all account's accessible namespaces
+    def namespaces?
+      t_namespaces=@linker.call("account","namespaces")
+      if(t_namespaces["status"].to_sym == :success)
+        out={}
+        t_namespaces["namespaces"].each do |namespace|
+          nm=Namespace.new(@linker,namespace["name"],namespace["size"],namespace["share_mode"].to_sym,namespace["owner"])
+          out[nm.name]=nm
+        end
+        return out
+      else
+        return {}
+      end
+    end
+    
+    # Obtain all the namespaces owned by the account owner (public and private)
+    def owned_namespaces?
+      namespaces?.reject {|key,value| !value.owner}
+    end
+    
+    # Obtain all account's private namespaces
+    def private_namespaces?
+      owned_namespaces?.reject {|key,value| value.shareMode!=:Private}
+    end
+    
+    # Retrieve informations about current account's limits
+    def limits?
+      out=@linker.call("account","limits")
+      if(out["status"].to_sym == :success)
+        return out["usage"]
+      else
+        return nil
+      end
+    end
+    
+    private
+    attr_accessor :linker
+  end
+end

data/lib/facer/faces.rb

@@ -0,0 +1,107 @@
+module Facer
+  # Base class to query the api on faces and tags info
+  # All the queries are in the "simplest form" of a single image/single user query
+  # In this version of the gem I assume to use "single face" images
+  # You can provide images as a file path or a public url, the library will treat them accordingly
+  class Faces
+    # Initialize the class passing a convenient linker reference
+    def initialize(linker)
+      @linker=linker
+    end
+    
+    # Detect if the provided image contains a face and, if yes, return face's informations
+    def detect(image,detector = :Normal)
+      ret={}
+      if(URI.parse(image).is_a?(URI::HTTP))
+        ret=@linker.call("faces","detect",{"urls" => image, "detector" => detector.to_s})
+      else
+        ret=@linker.call("faces","detect",{"detector" => detector.to_s},{"upload" => image})
+      end
+      if(ret["status"].to_sym == :success && ret["photos"].length == 1)
+        return ret["photos"][0]
+      end
+      return nil
+    end
+    
+    # Force train a user against the images/tags library
+    def train(user,namespace)
+      ret=@linker.call("faces","train",{"uids" => "#{user}@#{namespace}"})
+      return ret["status"].to_sym == :success
+    end
+    
+    # Force train all users in a namespace (veeeery long operation)
+    def train_all(namespace)
+      namespaces=@linker.account.private_namespaces?
+      if(!namespaces || !namespaces[namespace])
+        return false
+      end
+      users=namespaces[namespace].users?
+      success=true
+      users.each do |user|
+        success &= train(user,namespace)
+      end
+      return success
+    end
+    
+    # Attempt to recognize a user in a image end, if so, provide user and face infos
+    def recognize(image,namespace,users = "",detector = :Normal)
+      if(users.empty?)
+        users="all@#{namespace}"
+      end
+      ret={}
+      if(URI.parse(image).is_a?(URI::HTTP))
+        ret=@linker.call("faces","recognize",{"urls" => image, "uids" => users, "detector" => detector.to_s, "namespace" => namespace})
+      else
+        ret=@linker.call("faces","recognize",{"uids" => users, "detector" => detector.to_s, "namespace" => namespace},{"upload" => image})
+      end 
+      if(ret["status"].to_sym == :success && ret["photos"].length == 1)
+        img=ret["photos"][0]
+        if(img["tags"].length == 1)
+           tag=img["tags"][0]
+           if(tag["uids"] && tag["uids"].length>0)
+             return tag["uids"][0]
+           else
+             return {"confidence" => 0, "uid" => nil}
+           end
+        else
+           return {"confidence" => -1, "uid" => nil}
+        end
+      end
+      return nil
+    end
+    
+    # Associace many images to a user. I assume every images contains a single face
+    def associate_multi(images,user,namespace, force_train = false, detector = :Normal)
+      success=true
+      images.each do |image|
+        success &= associate(image,user,namespace,false,detector)
+      end
+      if(success && force_train)
+         return train(user,namespace)
+      end
+      return success
+    end
+    
+    # Associace a face image to a user. I assume the image contains a single face
+    def associate(image,user,namespace, force_train = false, detector = :Normal)
+      img=detect(image,detector)
+      if(img && img["tags"].length == 1)
+        tag=img["tags"][0]
+        if(tag["attributes"]["face"] && tag["attributes"]["face"]["value"].to_s == "true")
+          tid=tag["tid"]
+          ret=@linker.call("tags","save",{"tids" => tid, "uid" => "#{user}@#{namespace}"})
+          if(ret["status"].to_sym == :success)
+            if(force_train)
+              return train(user,namespace)
+            end
+            return true
+          end
+        end
+      end
+      return false
+    end
+    
+    private
+    attr_accessor :linker
+  end
+end

data/lib/facer/namespace.rb

@@ -0,0 +1,40 @@
+module Facer
+  # Base class to store informations and obtain infos on the namespace
+  class Namespace
+    attr_reader :name
+    attr_reader :size
+    attr_reader :shareMode
+    attr_reader :owner
+    
+     # Initialize the class passing a convenient linker reference and infos about the namespace
+    def initialize(linker,name,size,shareMode,owner)
+      @linker=linker
+      @name=name
+      @size=size
+      @shareMode=shareMode
+      @owner=owner
+    end
+    
+    # Retrieve namespace's user list
+    def users?
+      if(@owner && @shareMode==:Private)
+        t_users=@linker.call("account","users",{"namespaces" => @name})
+        out=[]
+        if(t_users["status"].to_sym == :success)
+           t_users["users"].each_pair do |key,namespace_users|
+              out+=namespace_users
+           end
+           return out
+        else
+          return []
+        end
+      else
+        return []
+      end
+      namespaces?.reject {|key,value| !value.owner}
+    end
+    
+    private
+    attr_accessor :linker
+  end
+end

data/lib/linker.rb

@@ -0,0 +1,52 @@
+require "net/http"
+require "net/http/post/multipart"
+require 'mime/types'
+require "uri"
+require "json"
+module Facer
+  
+ # This class hold the main linkage to face.com
+ # acting as a gateway to subclasses
+  class Linker
+    # The main uri to face.com api.
+    FaceComURI="http://api.face.com/"
+    
+    attr_reader :account
+    attr_reader :faces
+    
+    # Initialize the linker with security informations
+    def initialize(applicationName,key,secret)  
+      @account=Account.new(self,applicationName,key,secret)
+      @faces=Faces.new(self)
+    end
+    
+    # Call the service appending security informations to every request
+    def call(bclass,method,params = {},files = nil)
+      params ||={}
+      params["api_key"]=@account.apiKey
+      params["api_secret"]=@account.apiSecret
+      resp=callAPI(bclass,method,params,files)
+      return resp
+    end
+    
+    private
+    # Call the service using post or multiform data for sending files and transpose to json the response
+    def callAPI(bclass,method,params,files)
+      uri=URI.parse("#{FaceComURI}#{bclass}/#{method}.json")
+      params ||= {}
+      if(files)
+        files.each_pair do |name,path|
+          params[name]=UploadIO.new(path, MIME::Types.type_for(path))
+        end
+        req = Net::HTTP::Post::Multipart.new(uri.path,params)
+        res = Net::HTTP.start(uri.host, uri.port) do |http|
+          http.request(req)
+        end
+        return JSON.parse(res.body)
+      else
+        res = Net::HTTP.post_form(uri,params)
+        return JSON.parse(res.body)
+      end
+    end
+  end
+end

data/test/facer_test.rb

@@ -0,0 +1,8 @@
+require 'test/unit'
+
+class MimetypeFuTest < Test::Unit::TestCase
+  # Replace this with your real tests.
+  def test_this_plugin
+    flunk
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: facer
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Stefano Valicchia
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-11 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: multipart-post
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 1
+        - 0
+        - 1
+        version: 1.0.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 4
+        - 6
+        version: 1.4.6
+  type: :runtime
+  version_requirements: *id002
+description: Simple wrapper for face.com api.
+email: stefano.valicchia@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- Gemfile
+- Manifest.txt
+- README
+files: 
+- lib/facer/account.rb
+- lib/facer/faces.rb
+- lib/facer/namespace.rb
+- lib/facer.rb
+- lib/linker.rb
+- init.rb
+- Manifest.txt
+- Gemfile
+- README
+- test/facer_test.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- Facer
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: 
+- The gem uses multipart-post gem and JSON gem
+rubyforge_project: 
+rubygems_version: 1.4.1
+signing_key: 
+specification_version: 3
+summary: Wrapper for face.com API.
+test_files: 
+- test/facer_test.rb