This version (2012/08/19 18:10) is a draft.
Approvals: 0/1

LTU engine/server Description & User Guide

1. Introduction: Visual Search

Images finding images: LTU engine is the foundation for visual search: image matching, similarity search, and color search.

Visual search is using one image to find other images. Visual search based upon the content of an image, rather than based on textual information.

Two key technologies of visual search are image description and image search.

Image description (Indexation): The first step toward making an image searchable is to create a descriptor of the image content. LTU engine computes a visual signature for every image that describe its visual content in terms of color, shape, texture and many higher order visual features. These descriptors are also called image DNAs.

Image search: Image search is the comparison of one image signature with another, or with millions of other signatures. LTU's proprietary architecture includes a special comparison technology by which an image signature can be compared at extremely high speed with other image signatures.

The core data for LTU engine is the signature, also called the image DNA, not the image itself. Image signatures are presented in the “Create Application” section of the “Administrative Interface” guide below.


These principal functionalities are packaged in LTU engine, which provides the components necessary for creating and managing visual search applications, including JSON API and a comprehensive Administrative Interface.

2. Release note

LTU engine Version 6 has the following new features

New Feature Details
New administrative interface New interface to manage the LTU engine server and applications
Easy application management Applications may be managed directly from the Admin Interface: enable or disable applications, edit advanced parameters of applications,rename applications
Manage, create and reload applications (without system restart) Applications may be managed without restarting LTU engine.
Statistical tools Comprehensive statistics of general system utilization as well details of each individual applicaion. Statistics are available in graphic and numeric formats, and statistics may be exported in .csv files for further analysis.
View all queries effected on LTU engine The administrative interface includes visual logs of all queries, displaying both queries and results.
Matching zone Displaying the matching zone permits visualization of the common visual content in the query and reference images.

LTU engine 6 has the following changes in architecture :

Architecture Details
Faster response time for mobile applications Mobile configuration for optimized response time down to 500 ms whatever the database size.
Increased scalability LTU engine is now organized in many separate processes and services. That allows capacity adjustments without restarting the entire system.
New JSON API for system administation Every LTU administration action (query) can be now done directly via the new API.
New JSON API for image management and search No need to use any SDK, applications may be plugged directly on the JSON API.
External database manager no longer necessary LTU image signatures (image DNA) are stored by LTU engine server in an integrated database system; it is no longer necessary to install an external database manager.

3. System requirements

LTU engine server is a full 64-bit system and is supported in the following environments:

Operating System Distribution Version
Linux CentOS 6.x
Linux Red Hat Enterprise Linux 6.x
Linux Debian 6.x
Windows Server 2008


LTU engine Server 6 uses now an internal dna storage system. An external database manager is no longer necessary.

  • CPU: Dual Core CPU minimum
  • Mem: 2Go minimum without counting the memory needed by your application's DNA (Memory sizing will be in provided by support@ltutech.com).
  • Hard drive: 10Go minimum without image storage.

Information on application DNA memory sizes is in this documentation at: Create Application

4. Glossary

  • Application: An application database that contains image DNA’s (the image database), meta-information and various settings (including the functionality the application was created for – matching or similarity).
  • Application Key: Each application has a unique application key that is used to access the application.
  • Bounce: Taking a single DNA from an image database and comparing it to all DNA in the same image database.
  • Color Weight: Using LTU Tech’s similarity algorithm you can control the return results based on color weight. Using color weight, the search can be weighted on the colors of the entire image, entirely on the shapes of the image or any combination of the two.
  • Duplicate & Clone: A duplicate image is one that is where exactly all pixels have the same value as in the comparison image, any modification such as coloring or resizing makes the image a clone.
  • DNA & Signature: When an image has been indexed a binary string is generated called an image DNA or signature.
  • Global Matching: A global match detects if two images are exactly or very nearly the same.
  • Enrollment: Reference to the entire process of taking an image, indexing it to generate a DNA, storing the DNA and keywords, generating and storing a thumbnail and reference image to an application.
  • Image Database: Each application has its own database storage, in which a DNA is stored
  • Image DNA Type: Each DNA is designed for a specific feature (matching or similarity).
  • Image_ID: The image_id is a unique key to the client’s image within an application and for a client. The image_id can be thought of as a foreign key to the client’s database. The system will not accept duplicate image_id’s.
  • Indexation: The act of processing an image by an algorithm to generate a DNA.
  • Keywords: Each image entity may have a set of keywords (string) associated with it. These keywords are helpful for aiding and enhancing searches. Note: keywords may be duplicated across multiple images within a single image database but should not be duplicated on one image (eg. acceptable ‘red,dog,bed’, unacceptable ‘red,red,red,dog,bed’).
  • Local Matching: Local matching is able to find matching sub-sections of two images or images of the same object.

5. Administrative Interface

Both LTU engine /server and LTU engine /ON demand share the same Administrative Interface.

However, there are certain differences in

  • feature availability
  • API syntax

In this document, these differences are noted by text marked with this symbol: :!:

Creating new and managing existing applications are possible via the Administrative Interface of LTU engine/server. However, application paramenters should be modified only as instructed by JASTEC France Support.

Monitoring the performance of applications and authorizing IP access have been the primary purpose of the LTU engine/ON demand administrative interface.

The creation and configuration of applications remains the responsibility of JASTEC France Support.

New features were added to the Administrative Interface in July 2012: These include the Image Management tab which is detailed in this document.

Also, Visual Query Logs may be activated on individual applications (to activate Visual Query Logs, please contact JASTEC France Support.

  • Image Management - Browse Images
  • Image Management - Bounce Search with Display of Matching Zones
  • Image Management - Batch Processes via the Administrative Interface
  • Statistics - Numeric and Graphical
  • Statistics - Visual Query Logs


Manage Applications - Applications Dashboard

The Dashboard displays information about all applications (Active and Inactive)

  • Active Applications Includes graphic indicators of the status of each application.
  • Inactive Applications Information on applications which are still present on the disk storage system but are not loaded into memory, thus not available for queries
  • Get Image ID's For creation and download of a .csv file containing the image ID's and keywords for all images in the application.


Application Parameters - Display and Update




Reminder: Application parameters should not be changed unless advised by JASTEC France support.

  • Name: Application Name may be changed here at any time without affecting operations. Application names should contain no accents or special characters. Spaces are permitted. Maximum name length: 256 charcters.
  • Status: Unchecking this box will make the application Inactive. Image signatures are unloaded from system memory.
  • Application Search DNA: Different from the “Application DNA”, the “Application Search DNA” is a parameter for certain types of Image Matching applications. It functions on external images, creating a larger, more detailed image signature, which is effective in applications where query images may be of varying quality, such as mobile applications.

For information on signatures, see section Create Application

  • Color Weight Applicable only to “Image Similarity” applications.“Color Weight” is the default color weight used when not specified in the query (SearchImageByDna or SearchImageByUpload). Default: “50” (balance between Color and Shape). Weighted for form: “0”. Weighted for color: '100“.
  • Save query logs days This affects the Batch search reports as well as invididual queries.
  • Number of Results: Default number of results when not specified in the query. Applies to API queries as well as to queries via the Admin Interface (number of bouce results, displayed, for example).
  • Retrieval Threshold: Threshold on retrieval results. Image with a score superior to this threshold will NOT be returned. -1 means no threshold.
  • Comments: Any comments describing specifics of the application.

Application Status

  • Last Add: Time elapsed since last AdImage, whether effected via the API or via the Admin Interface.
  • Last Search: Time elapsed since last SearchImage, whether effected via the API or via the Admin Interface.
  • Number of Kimas: Number of kima processes associated with this application. This number is automtically adjusted by the system may not be modified via the Admin Interface.
  • Images: Total number of images in the application.
  • Keywords: Since individual images may have multiple keywords, this number may be larger than the number of images.
    Reminder - for images enrolled via the Admin Interface (Image Management, batch process, Add images) keywords are automatically generated if the submitted zip file is organized by subdirectories. Keywords are generated for all levels of the file hierarchy.

    Also see the API Methods section (AddImage and SearchImage…) for additional information about keywords.

Advanced Management Status Information

  • Update messages and codes: Values are:

0: the application has never been updated by the manager process 1: the application is currently queued for update 2: an update is currently running for the application 3: an update has already been run for this application (normal state) 4: an update failed

  • Next update: Applications are automatically when necessary
  • Last generation: “Generation” means update of the application.

Advanced Actions: Update, Rebuild, Reload

Unless instructed by JASTEC France support, it is generally unnecessary to perform these actions.

Note: None of the following actions deletes data from disk storage.

These actions concern the reloading of data elements into system memory. An application is temporarily disabled during the execution of these functions.

  • Update Application: Adds new elements, such as new image signatures, to system memory. However, this is done automatically during standard update procedures, such as AddImage or addImageBatch.
  • Rebuild Application: Unload and Reload: unloads the application from system memory, and completely reloads the application from the database.
  • Reload Configuration As distinguished from application content (which is updated or reloaded by Update and Rebuild Application), this action reloads application parameters. However, this is done automatically “Apply Modifications” is selected after application parameters are modified.

Display: Other application information

  • Creation Date: Display only.
  • Application Key: Display only. The application key is generated at aplication creation and may not be changed.
  • Application DNA Type: Display only. Displayed in long form: 70001000 = 70.1.1.
    Application DNA type cannot be changed once an application is created. To change a DNA type for a set of images, a new application must be created, and the images must be indexed in the new application.
  • Application Type: Display only. The category (Image Matching, Image Similarity) of the Application Type selected at application creation.
  • Folder path: This is the location of the images of an application.
  • Database Location: For information only; significant only for special configurations involving a database on a separate server.
  • Retrieval Threshold: Display only of the retrieval threshold currently in effect. May be modified via the “Application parameters” form, if so advised by JASTEC France support.

Create Application

:!: LTU engine/server only. For LTU engine/ON demand, applications are created by JASTEC France support.

  • Name: Application names should be limited to fewer than 256 characters, with no accents or special characters. Spaces are permitted.
  • Application Type: The choice of “Image matching” or “Image similarity” determines which signatures will be displayed as available options for the application.
  • Application DNA: Explained here following:

Matching Signatures

Type Signature ID Options Signature Size (bytes)
In Memory
Use and Characteristics
Media Monitoring 65.0.0 Flip invariant 3900 Media intelligence Recommended Signature- high speed indexation and retrieval in large applications.
Mobile Matching 70.1.2 Asymetric Retrieval 7500 Mobile Applications
Mobile Matching 72.4.0 Asymetric Retrieval 10000 (average) Recommended Signature Large scale Mobile Applications


Asymetric Retrieval: Asymetric Retrieval is automatically activated for applications whose signature includes the option. Asymetric Retrieval applies to external queries (SearchByUpload): a large temporary signature (not stored in the application) is calculated for the external query image, which is then compared with the application images.

Similarity Signatures

Signature ID Options Signature Size (bytes)
In Memory
Use and Characteristics
4.2.0 query weighting Color/Form 1340 Image similarity search

Color Signatures

Signature ID Options Signature Size (bytes)
In Memory
Use and Characteristics
8.0.0 query weighting Color/Form 897 Dominant colors signature
8.1.0 query weighting Color/Form 897 Same as 8.0 but with uniform background removal

Browse Images

The Browse Images feature of Image Managment allows a display of all images present in an application.

Images are arranged chronologically (images last added are displayed first).

Page controls allow browsing the entire database

Browse Images - Search Image

Any image selected via the Browse Images page may be used as a search query:


Clicking on a result image shows a display of the matching zone.

Run Batch Process

Add Images

For the selected application, images may be added by uploading a zip file. Filenames must be unique across the zip file, since the filename is used as the image id.

Keywords: Keywords may be associated with images added via this process. Folder names are used as keywords for the images. This may include multiple levels. In the example below, during indexation, images are assigned keywords according to where the image files are found in the folder directory tree.

A batch add process may be designated by a Report Name. The report is timestamped and may be accessed later to know the number of images enrolled.

Search Images

Batches of images may be submitted as queries. The batch search may be designated by a Report Name. The batch search report maybe accessed later, and includes displays of the query images and the results.

Previous Batch Processes

Batch processes described above are accessed via these links.

Advanced Usage: Test API Queries

This page provides a simple way to understand the functioning of the principal queries. For the selected application, query parameters may be entered via the screen interface. The display then shows both the json response and,if applicable, the associated images.

The Statistics tab gives access to numeric and graphical measures of system utilization.

It also provides access to Visual Query Logs, which permit the viewing of all search queries effected on the system. The logs display the query image and the results, ranked according to proximity score.


For applications using one of the Matching signatures, the Query Logs view permits the viewing of teh “Matching Zone”. Clicking on any one of the result images displays the Matching Zone for the query image and the result image:


6. API

The principal API's are used for

  • Image Management (add and delete images: AddImage; DeleteImage)
  • Image Search (retrieving images: SearchImageByUpload; SearchImageById; SearchImageByDna; SearchImageByKeywords)


Special Use API's are used for:

  • Status Information on Images (GetImageByID - exists in two forms)
  • Status Information on Applications (GetApplicationStatus - exists in two forms)


All LTU engine queries fall into one of two general API categories: MODIFY or QUERY.

:!: For LTU engine/ON demand, the url of the query examples given in the following pages should be modified as follows :


For LTU engine/server

  • MODIFY - addressed via port 7789
  • QUERY - addressed via port 8080



Some LTU engine API queries exist in two versions (MODIFY & QUERY), discussed below under “Special USE API's”.

The LTU engine API is accessible over the HTTP protocol. LTU engine requires a GET or a POST request as input, and returns an HTTP response with the application/json mimetype, which contains the response serialized as a JSON string.

Example:

GET http://localhost:8080/api/v2.0/ltuquery/json/SearchImageById?application_key=j6hcA7bwb1jcF8grn6msWNoziUSbXWab&image_id=myimage.jpg


JSON response


  {
 "images":[
    {
     "keywords":["office"],
     "score":0,
     "id":"TO-018.jpg",
     "result_info":"{
  "category" : "LOCALMA..."
    }],
 "status":
  {
   "message":"No error",
   "code":0
  },
 "nb_results_found":1
}

In this documentation, you will find a list of all API methods.

Each section will :

  • quickly explain what the method does.
  • define what type of HTTP request is accepted (GET, POST or both).
  • define each parameter the method takes as input, its type, valid values, and whether it is mandatory or optional.
  • give an example response, with comments.

Some notions are common to quite a few API methods :

  • application key : it is a unique identifier for an application. It needs to be present in ALL your LTU engine requests.
  • image id : it is a unique identifier of an image inside an application. When adding an image, you provide an image id. The results of searches in a LTU engine application will be image ids.

The modify API is usually exposed on http://localhost:7789/api/v2.0/ltumodify/json

AddImage

  • Request type : POST
  • Parameters :
    • application_key : string.
    • image_id : string. The unique identifier of the image.
    • image_content : binary. the content of the image file (the raw array of bytes in the image).
    • dna : binary. a byte array representing the precomputed DNA for the image. Note that you are supposed to provide at least image_content or dna, but never both.
    • keywords : strings. (can be repeated within the request) : one or more keywords that will be associated to this image. See syntax below.
  • Simple example, curl, adding an image with two keywords (a,b):

CURL query

curl -sL -F "image_content=@pinpin.jpg" 
'http://hostaddress:7789/api/v2.0/ltumodify/json/AddImage?application_key=PXly9fRUfUt0oizKTcmpzFS8AAtqrTgI&image_id=pinpin&keywordsa&keywords=b'

JSON response
{
 "status":
  {
   "message":"Image added to the reference database",
   "code":0
  },
 "task_id":0
}

DeleteImage

  • Request type : GET
  • Parameters :
    • application_key.
    • image_id : a string. The unique identifier of the image.


CURL query

curl -sL 
'http://hostaddress:7789/api/v2.0/ltumodify/json/DeleteImage?application_key=PXly9fRUfUt0oizKTcmpzFS8AAtqrTgI&image_id=pinpin'


JSON response

{
 "status":
  {
   "message":"Image deleted from the reference database",
   "code":0
  },
 "task_id":0
}

The modify API is usually exposed on http://localhost:7789/api/v2.0/ltuquery/json

There are 4 main methods to run search queries :

  • SearchImageByUpload
  • SearchImageByDna
  • SearchImageById
  • SearchImageByKeywords


All of these search methods have parameters in common. They are described here :

Common Parameters

Parameter Description
keywords Restrict the search to a list of keywords. Images that do not have these keywords will be discarded in the search.
color_weight Applicable only to “Image Similarity” applications.”Color Weight” is the default color weight used when not specified in the query(SearchImageByDna or SearchImageByUpload). Default: “50” (balance between Color and Shape). Weighted for form: “0”. Weighted for color: '100”.
nb_results Return at most this many result images, never more. Even if there are 100 matching images, setting nb_results means the result will contain only ten images. They will be the ten images with the best scores if starting_index is 0.
starting_index Do not return results starting with the best score, but with the given index in the results. For example, setting starting_index to 10 will return images starting with image that has the 11th score.
ids_list Restrict the search to the images in this list. ex: “id1; id2; id3”

SearchImageByUpload


  • Runs an image search on an application, using an uploaded image as the query.
  • Request type : POST
  • Required Parameters :
    • application_key
    • image_content : The contents (raw array of bytes) of the request image.
  • Optional Parameters :
    • keywords: A list of keywords to which the search should be restricted
    • color_weight. (Similarity Search only) Uses application default color_weight if parameter not provided.
    • starting_index.
    • nb_results.
    • ids_list.


CURL query

curl -sL -F "image_content=@pinpin.jpg" 
'http://hostaddress:8080/api/v2.0/ltuquery/json/SearchImageByUpload?application_key=PXly9fRUfUt0oizKTcmpzFS8AAtqrTgI'



JSON response

{
  "images":[
    {
     "keywords":[],
     "score":0,
     "id":"some_image.jpg",
     "result_info":""
    },
    {
     "keywords":[],
     "score":0.719954,
     "id":"some_other_image.jpg",
     "result_info":""
    }],
 "status":
  {
   "message":"No error",
   "code":0
  },
 "nb_results_found":100
}

SearchImageById

SearchImageById is not available with asymetric DNA. This means you cannot send a SearchImageById request on Mobile Matching applications. You will receive instead a -2609 error code.

  • Runs an image search on an application, taking an image from the database as the query.
  • Request type : GET
  • Required Parameters :
    • application_key
    • image_id : The id of the query image.
  • Optional Parameters :
    • keywords: A list of keywords to which the search should be restricted
    • color_weight. (Similarity Search only) Uses application default color_weight if parameter not provided.
    • starting_index.
    • nb_results.
    • ids_list.

\\
CURL query

curl -sL 
'http://hostaddress:8080/api/v2.0/ltuquery/json/SearchImageById?application_key=PXly9fRUfUt0oizKTcmpzFS8AAtqrTgI&image_id=pinpin'


JSON response

{
  "images":[
    {
     "keywords":[],
     "score":0,
     "id":"some_image.jpg",
     "result_info":""
    },
    {
     "keywords":[],
     "score":0.719954,
     "id":"some_other_image.jpg",
     "result_info":""
    }],
 "status":
  {
   "message":"No error",
   "code":0
  },
 "nb_results_found":100
}

SearchImageByDna

  • The equivalent of a SearchImageByUpload, but where the DNA is precomputed

on the client, and sent directly, without sending the image.

  • Request type : POST
  • Required Parameters :
    • application_key
    • dna : The DNA of the image.
  • Optional Parameters :
    • keywords: A list of keywords to which the search should be restricted
    • color_weight. (Similarity Search only) Uses application default color_weight if parameter not provided.
    • starting_index.
    • nb_results.
    • ids_list.


For information concerning use of pre-computed DNA's, please contact JASTEC France support.

JSON response

{
  "images":[
    {
     "keywords":[],
     "score":0,
     "id":"some_image.jpg",
     "result_info":""
    },
    {
     "keywords":[],
     "score":0.719954,
     "id":"some_other_image.jpg",
     "result_info":""
    }],
 "status":
  {
   "message":"No error",
   "code":0
  },
 "nb_results_found":100
}

SearchImageByKeywords

  • Returns all image ids that contain all keywords in a list.
  • Request type : POST
  • Required Parameters :
    • application_key
    • keywords.
  • Optional Parameters :
    • keywords: A list of keywords to which the search should be restricted
    • color_weight. (Similarity Search only) Uses application default color_weight if parameter not provided.
    • starting_index.
    • nb_results.
    • ids_list.


Simple example, curl, keywords (a,b):
CURL query

curl -sL 
'http://hostaddress:8080/api/v2.0/ltuquery/json/SearchImageByKeywords?application_key=PXly9fRUfUt0oizKTcmpzFS8AAtqrTgI&keywords=a&keywords=b'


JSON response
{
  "images":[
    {
     "keywords":['keyword'],
     "score":0,
     "id":"some_image.jpg",
     "result_info":""
    },
    {
     "keywords":['keyword'],
     "score":0.719954,
     "id":"some_other_image.jpg",
     "result_info":""
    }],
 "status":
  {
   "message":"No error",
   "code":0
  },
 "nb_results_found":100
}

The Color Search API's apply only to applications created as “Color similarity” application types.

GetImageColorsById

This query identifies the dominant colors present in an image.

  • Request type : GET
  • Required Parameters :
    • application_key
    • image_id
  • Optional Parameters :None


Simple example, curl:
CURL query

curl -sL 
'http://hostaddress:8080/api/v2.0/ltuquery/json/GetImageColorsById?application_key=PXly9fRUfUt0oizKTcmpzFS8AAtqrTgI&image_id=pinpin'

JSON response

{
 "status":
  {
   "message":"",
   "code":0
  },
 "colors":["F2F2F2@94","A9B5B6@2","EAA453@1","D5C0A3@1","2B9755@1","A0C99A@1"]
}

GetImageColorsByUpload

This query identifies the dominant colors present in an uploaded image.


  • Request type : GET
  • Required Parameters :
    • application_key
    • image_content: the path to the image to be uploaded.
  • Optional Parameters :None


Simple example, curl: CURL query

curl -sL -F "image_content=@pinpin.jpg" 
'http://hostaddress:8080/api/v2.0/ltuquery/json/GetImageColorsByUpload?application_key=PXly9fRUfUt0oizKTcmpzFS8AAtqrTgI'


JSON response

{
 "status":
  {
   "message":"",
   "code":0
  },
 "colors":["B9A595@24","71715A@20","E1DFDB@12","494938@10","1E1B12@7","946C57@5","030203@5","0A0915@3","866939@3","0B0B07@2","5B3E26@2","3C2909@2","CAB978@1","B79439@1","382911@1","150E14@1","6E6076@1"]
}

SearchImageByColors


  • Request type : GET
  • Required Parameters :
    • application_key
    • colors (array of strings) as hex value (see syntax below). It is possible to add target weights for color (FFFFFF@50 would search for colors of which 50% of pixels are white (FFFFFF).
  • Optional Parameters :
    • keywords (array of strings)
    • starting_index (integer)
    • nb_results (integer)
    • ids_list (string)


Simple example, curl:
CURL query

curl -sL 
'http://hostaddress:8080/api/v2.0/ltuquery/json/SearcImageByColors?application_key=PXly9fRUfUt0oizKTcmpzFS8AAtqrTgI&colors=FF6633&colors=FF99'

JSON response:

{
 "images":[
    {
     "keywords":["Seurat"],
     "score":0.741319597,
     "id":"Sunday_Afternoon_Island_G...",
     "result_info":""
    }],
 "status":
  {
   "message":"No error",
   "code":0
  },
 "nb_results_found":1
}

GetPalette

http://127.0.0.1:8080/api/v2.0/ltuquery/json/GetPalette

Method: GET

  • Request type : GET
  • Required Parameters :
    • application_key
  • Optional Parameters :
    • colors (array of strings) as hex value (Returns palette of all images which contain these colors).
    • keywords (array of strings)
    • nb_colors (integer):
    • ids_list (string):

Simple example, curl:
CURL query

curl -sL 
'http://hostaddress:8080/api/v2.0/ltuquery/json/GetPalette?application_key=PXly9fRUfUt0oizKTcmpzFS8AAtqrTgI&colors=FF6633&colors=FF99'


{
 "status":
  {
   "message":"",
   "code":0
  },
 "colors":["735238","8F938E","2D5E95","382711","393126","846834","C3973A","CFB076","E9EAEB","943112","AA834F","D91E25","090A05","0A0E30","B15A4A"],
 "image_count":[5,4,3,3,3,3,3,3,3,2,2,2,1,1,1]
}

Image Fine Comparison


Fine comparison is designed to provide additional details on the results of query and reference matches using LTU’s image matching functionality. The fine image comparison feature provides visual feedback about matched images, pinpointing where the subtlest differences are located.

Fine comparison also provides a numeric score to quantify the differences between the two images.

Fine comparison is used to: Automate the identification of differences between two matching images R Visually highlight the differences between two images.
http://hostaddress:8080/api/v2.0/ltuquery/json/FineComparison

  • Request type : POST
  • Required Parameters :
    • application_key
    • ref_image
    • query_image


The reference image and the query image are base64 encoded.


Simple curl example: CURL query

curl -F "reference_image=@fic1.jpg" -F "query_image=@fic2.jpg" "http://hostaddress:8080/api/v2.0/ltuquery/json/FineComparison?application_key=VmLGHUj9yXA731RD0Hzp9svWCb5MtMY1" 

JSON response:

{
  "ref_image": "base 64 encoded diff on the reference image",
  "query_image": "base 64 encoded diff on the query image",
  "score": 1.2381811141967773,
  "status": {
    "message": "",
    "code": 0
  }
}

Filtering


Filtering is designed to decide whether an image corresponds to a given profile, such as Porn.

It also provides a numeric score to quantify the confidence of the classification.
http://hostaddress:8080/api/v2.0/ltuquery/json/Filter

  • Request type: POST
  • Required parameters:
    • application_key
    • query_image


In this kind of applications, no reference image is needed, as the query image is directly compared to the profile.


Simple curl example:
CURL query

curl -F "image_content=@filter.jpg" "http://hostaddress:8080/api/v2.0/ltuquery/json/Filter?application_key=VmLGHUj9yXA731RD0Hzp9svWCb5MtMY1" 

JSON response:

{
 "status":
  {
   "message":"No error",
   "code":0
  },
 "scores":
  {
   "Porn":-0.7200000286102295
  }
}

GetApplicationStatus - QUERY version

  • Returns the status of an application (how many images are loaded, etc.)
  • Request type : GET
  • Required Parameter: application_key


Simple curl example:
CURL query

curl -sL 
'http://hostaddress:8080/api/v2.0/ltuquery/json/GetApplicationStatus?application_key=PXly9fRUfUt0oizKTcmpzFS8AAtqrTgI'


JSON response

{
  "status": {
    "message": "No error",
    "code": 0
  },
  "nb_loaded_images": 227
}

GetApplicationStatus - MODIFY version

  • Returns the status of an application (wether it is correctly loaded, etc.)
  • Request type : GET
  • Required Parameter : application_key


Simple curl example:
CURL query

curl -sL 
'http://hostaddress:7789/api/v2.0/ltumodify/GetApplicationStatus?application_key=PXly9fRUfUt0oizKTcmpzFS8AAtqrTgI'



JSON response

{
  "status": {
    "message": "No error",
    "code": 0
  },
  "application_db_status": "available",
  "main_db_status": "available"
}

GetImageById - QUERY version

  • Returns the image that has the given unique id. Request type : GET
  • Parameters : application_key, image_id


JSON response

{
  "status": {
    "message": "No error",
    "code": 0
  },
  "image": {
    "keywords": ["keyword"],
    "score": 0,
    "id": "COSMOS00145488_000001.jpg",
    "result_info": ""
  }
}

GetImageById - MODIFY version

  • Returns information about an added image. Request type : GET
  • Parameters : application_key, image_id

Simple example, curl:
CURL query

curl -sL 
'http://hostaddress:8080/api/v2.0/ltuquery/json/GetImageById?application_key=PXly9fRUfUt0oizKTcmpzFS8AAtqrTgI&image_id=pinpin'


JSON response

{
  "status": {
    "message": "No error",
    "code": 0
  },
  "image": {
    "keywords": [
      "some_keyword"
    ],
    "score": 0,
    "id": "da97e15e6b2faa06b1cd3708bf52ee1e.jpg",
    "result_info": ""
  }
}

7. Installling and Configuring

Required Files


The two essential software components for installing LTU engine are:

  • LTU engine software: delivered as a .zip file (same file for both Linux and Windows).
  • LTU license file: a machine-specific license key necessary for installing and activating the software.

Installation Steps


  • Windows: Edit file c:/windows/system32/drivers/etc/hosts and add this: 127.0.0.1 YOUR_HOSTNAME_HERE_FROM_IP_CONFIG
  • Unzip the installation software to a temporary directory.
  • Copy the license file to the same temporary directory
  • Linux: logged in as “root”, in the temporary directory, execute the script install.sh
  • Windows: logged in as Administrator, from a command line window in the temporary directory, execute the script install.bat


All system components will be installed and lauched via this single command.

Upgrade Steps


  • Unzip the installation software to a temporary directory.
  • Linux: logged in as “root”, in the temporary directory, execute the script install.sh and follow the instructions.
  • Windows: logged in as Administrator, from a command line window, run sc stop ltuengine. Then go in the temporary directory, execute the script install.bat and follow the instructions.



Linux: logged in as root: /etc/init.d/ltud [option]
options: start, stop, status all, restart

Windows: logged in as Administrator: The service “ltuengine” may be stopped and restarted via the Services panel of the Windows Server Task Manager.


The procedures described below are not available for distributed installations. Also it is not yet possible to restore the installation directly on a different machine. For such cases please contact us at support@ltutech.com

Backup

To help you backup your LTU engine installation we have created a script located in the archive file given to you under the scripts directory. Note that this script is only available for versions of the product greater than 6.2.5. However if you wish to backup your installation but have an earlier version please contact us at support@ltutech.com

What this script does:

  • Save all your data related to your LTU engine installation in a single archive file.
  • Enables you to keep doing searches while the system is being backed up. However it is impossible to add or remove images during the backup i.e. the Modify API will not be available.


To backup your LTU engine installation run the following commands as root:

cd <directory/where/you/unzip/your/ltuengine/archive/>
./scripts/backup.sh <directory/to/you/ltuengine/installation>


The output of the backup script will tell you where the archive file is located. You can then move this file around to your own storage file system. Note that the backup file will get bigger as you add content to your LTU engine installation.

Restore

Important: If you're restoring your engine's backup on a fresh instance, please install the product first and then follow the procedure below.

The following steps can only be used to restore a backup file created via the backup script described above.

To restore your LTU engine installation run the following commands as root:

/etc/init.d/ltud stop
cd <directory/to/you/ltuengine/installation>
rm -rf <installation/directory>
tar xvf <path/to/your/archive/file> 
/etc/init.d/ltud start


The system will be back to the state it was in right before the backup.

LINUX

Before unzipping the ltu-engine.zip:


1. On your EC2 admin interface, go to Security policy:

  • add tcp port 8888
  • add tcp port 7789
  • add tcp port 8080
  • add tcp port 8081


2. System configuration :

  • Add your hostname to `/etc/hostname` and Refresh the hostname configuration:
$> echo "<hostname>" > /etc/hostname
$> hostname -F /etc/hostname


  • Add the external Amazon IP and hostname to `/etc/hosts`:
/etc/hosts
<external Amazon IP address>     <hostname>


  • Add the external Amazon IP address to `/etc/network/interfaces` as a loopback entry:
/etc/network/interfaces
iface lo:0 inet static 
  address <external Amazon IP address>
  netmask 255.255.255.255



WINDOWS

Before unzipping the ltu-engine.zip:

  1. Nothing special to do, except: on your EC2 admin interface, go to Security policy:
    • add tcp port 8888
    • add tcp port 7789
    • add tcp port 8080
    • add tcp port 8081
1 - On all hosts
  • Install unzip command.
  • Edit /etc/hosts in order to add all IP and hostnames of the hosts that will be used for the installation:
    • Make sure machine hostname do not refer to the loopback address (127.0.0.1) for license subsystem to work correctly.
  • Unzip ltu-engine archive
  • Copy the spec and the license files provided by JASTEC France in the extracted folder
2 - On kima hosts
  • Install rsync server
  • Configure rsync by editing /etc/rsyncd.conf:
    uid     = ltu
    gid     = ltu                                                                                                                                                                                                       
    list    = yes
    [saas]
    path = <install_dir>/data/ltu
    comment = sql lite folder for kima
    read only = false
    hosts allow = <database host> ( support mask 10.1.0.0/16 )
  • Edit /etc/default/rsync.conf and set RSYNC_ENABLE to true
  • Run “/etc/init.d/rsync start”
3 - On database host
  • Go to the ltu-engine extracted folder
  • Run ./install.sh -i <path_to_spec>
  • Run /etc/init.d/ltud stop all
  • Configure NFS to share <install_directory>/data among all cluster hosts:
    • Make sure NFS server is started at system start and words correctly
    • Edit /etc/exports:
<install_directory>/data/ 10.1.0.0/255.255.0.0(rw,sync,no_subtree_check,insecure)
  • restart nfs
4 - On non-database hosts
  • Go to the ltu-engine extracted folder
  • Run ./install.sh -i <path_to_spec> -n
  • Run “/etc/init.d/ltud stop all”
  • Configure you system to mount shared folder at the right place in /etc/fstab:
<database_host>:<install_dir>/data/ltu/storage <install_dir>/data/ltu/storage nfs rw,noatime,sync 0 0
<database_host>:<install_dir>/data/ltu/queue <install_dir>/data/ltu/queue nfs rw,noatime,sync 0 0
<database_host>:<install_dir>/data/ltu/query <install_dir>/data/ltu/query nfs rw,noatime,sync 0 0
<database_host>:<install_dir>/data/ltu/reports <install_dir>/data/ltu/reports nfs rw,noatime,sync 0 0
<database_host>:<install_dir>/data/ltu/ftp <install_dir>/data/ltu/ftp nfs rw,noatime,sync 0 0
  • Create folders:
    • mkdir -p <install_dir>/data/ltu/{storage,queue,query,reports,ftp}
  • Mount all folders:
    • mount -a
5 - On database host
  • Generate and distribute a suitable ssh configuration for ltu user:
    • ssh-keygen -t rsa -P“” # will generate ssh key
    • cat ~/.ssh/id_rsa.pub > ~/.ssh/authorized_keys # will add this key to the authorized keys
    • Run the following command will add all cluster hosts to the known_hosts file:
      • for host in [<list_of_hosts>]; do ssh-keyscan -t rsa $host » ~/.ssh/known_hosts; done
    • Copy the .ssh folder located in the ltu home directory on every hosts
  • /etc/init.d/ltud start all
6 - On all other hosts
  • /etc/init.d/ltud start all

I can't start LTU engine because license server can't start under CentOS 6?

Run /opt/ltuengine/deps/license/lmhostid, if you have something like this: The FLEXnet host ID of this machine is “000000000000”. You need to rename your ethernet interface to eth0. To do that you will need to:

  • /etc/sysconfig/network-scripts/ifcfg-NAME_OF_YOUR_INTERFACE to /etc/sysconfig/network-scripts/ifcfg-eth0
  • Edit /etc/sysconfig/network-scripts/ifcfg-eth0 and modify the first line to DEVICE=“eth0”
  • Edit /etc/udev/rules.d/70-persistent-net.rules and modify the NAME=“NAME_OF_YOUR_INTERFACE” to NAME=“eth0”

I have a local issue with my installation. (FATAL: invalid value for parameter)

Console output:

FATAL:  invalid value for parameter "lc_messages": "en_US.UTF-8"
pg_ctl: could not start server
Examine the log output.
Couldn't start the database.
Couldn't install the database service.
  • You need to install locales en_US.UTF8.

I want to deactivate the image storage for an application

This procedure can't be revert !

Run this:

su - ltu
ltud stop collector
ltud stop weki
export MY_APPLICATION_KEY='....................'
dir_to_delete=`psql -p 7791 saas_si -qtc "update application_property set value=false from application where application_property.name='save_ref_image' and application.id_application=application_property.id_application and application.application_key='$MY_APPLICATION_KEY';select sw_conf.value || '/' || client.folder_path || '/' || application_property.value from application, application_property, sw_conf, client where application.id_application = application_property.id_application and client.id_client = application.id_client and sw_conf.name='storage_root_folder_path' and application_key='$MY_APPLICATION_KEY' and application_property.name='folder_path';"`
rm -rf $dir_to_delete/*
ltud start collector
ltud start weki

I want to change my cores configuration


license feature configuration keys role
weki_nb_cores WEKI_NB_CORES * OPENMP_NUM_THREADS number of weki threads
processor_nb_cores PROCESSOR_NB_CORES * OPENMP_NUM_THREADS number of processor threads
kima_nb_cores KIMA_NB_CORES * OPENMP_NUM_THREADS number of launched kima threads
kima_nb_connections WEKI_KIMA_NB_CONNECTIONS maximum number of weki connections on kima
  • Update the configuration file: add the key/value you want to /opt/ltuengine/config/ltuengine.spec


  • Let's take an example:

My license allows me to a kima_nb_cores = 8 and I rarely make simultaneous requests. In this case, I can decide to reduce KIMA_NB_CORES in favor of OPENMP_NUM_THREADS:

"KIMA_NB_CORES": 2,
"OPENMP_NUM_THREADS": 4,


  • Once you updated the spec file, you must re-generate the configuration files to take your changes into account:
su - ltu
ltusaas-generate-config-files -i /opt/ltutengine/config/ltuengine.spec -m all -o /opt/ltu/env/run/cache/config
ltud restart all

I want to forward logs to syslog


  • Edit your spec file located here: /opt/ltutengine/config/ltuengine.spec
  • Update and add these lines:
    "SYSLOG_HANDLER_LOG_LEVEL": "INFO",
    "SYSLOG_LOG_FORMAT_PREFIX": "saas-standalone",
    "SYSLOG_LOG_FORMAT": "%(SYSLOG_LOG_FORMAT_PREFIX)s[%%(threadName)s] %%(levelname)s [%%(name)s::%%(funcName)s] %%(message)s",
    "SYSLOG_FACILITY": "LOG_LOCAL7",
    "ENABLE_SYSLOG": "True",
    "ENABLE_FILE_LOGGING": "False",


  • Then run this command to reload your configuration:
su - ltu
ltusaas-generate-config-files -i /opt/ltutengine/config/ltuengine.spec -m all -o /opt/ltu/env/run/cache/config
ltud restart all

8. Image Formats Supported

Any image sent to LTU engine must be in of the following formats:

  • PNG
  • GIF
  • JPEG, JPG
  • BMP

You will need to convert your images to one of these formats before sending them to LTU engine.

  • We recommend using images of 512 x 512 pixels when adding or searching images
  • Images data/file size should not be smaller than 50kb



  • Images can be converted to gray