Reverse image search API

We are excited to inform you about the newly introduced features in Aspose.Imaging Cloud API. Now it supports website-based image source for reverse image search. The image deskewing feature also makes the API second to none. We are continuously working and improving to offer you the best solutions possible.

Reverse image search is useful for finding duplicate or similar images. It can also help to monitor obscene or graphic content. You can also counter copyrights violations or trademark counterfeit by searching digitally signed images with the reverse search. Moreover, image deskewing is another feature that adds value to Aspose.Imaging Cloud API. It is also relevant to scanned PDF documents where skewed images often exist. Such PDF documents are frequently converted to searchable PDF documents where the results can be improved by deskewing the images. Let us dissect these features below.

Reverse Image Search using Aspose.Imaging Cloud SDK for Python

Several SDKs are available to communicate with Aspose.Imaging Cloud API. The SDKs take care of all minor details so that you can proceed with your requirements hassle-free. The SDKs include .NET, Java, Python, PHP, Ruby, Android, and Node.js. Here we will be working with a Python example:

First of all, you would need a free sign up at Aspose.Cloud. Install Python 2.7 or later and then add the following PyPi package to your requirements.txt.

aspose-imaging-cloud>=20.1

Now import the dependencies as under:

import aspose-imaging-cloud

Now, you can use below Python code to call the APIs and test the feature:

def search_image_from_web_source(self):
"""Finds the similar images from the URL source"""
print('Finds similar images from URL:')
similarity_threshold = 30.0
max_count = 3
folder = ImagingAiBase.CLOUD_PATH # Folder with image to process
storage = None # We are using default Cloud Storage
# Add images from the website to the search context
image_source_url = urllib.quote_plus('https://www.f1news.ru/interview/hamilton/140909.shtml')
self._imaging_api.create_web_site_image_features(
requests.CreateWebSiteImageFeaturesRequest(self._search_context_id, image_source_url, folder, storage))
self._wait_idle(self._search_context_id)
# Download the image from the website
image_data = req.get('https://cdn.f1ne.ws/userfiles/hamilton/140909.jpg')
path = os.path.abspath(os.path.join(ImagingAiBase.OUTPUT_FOLDER, 'WebSearchSample.jpg'))
with open(path, "wb") as f:
f.write(image_data.content)
# Resize downloaded image to demonstrate search engine capabilities
resized_image = self._imaging_api.create_resized_image(requests.CreateResizedImageRequest(
path, 600, 400, "jpg", storage=storage))
# Upload image to cloud
image_name = 'ReverseSearch.jpg'
self._imaging_api.upload_file(requests.UploadFileRequest(ImagingAiBase.CLOUD_PATH + "/" + image_name,
resized_image, storage))
# Find similar images in the search context
find_response = self._imaging_api.find_similar_images(
requests.FindSimilarImagesRequest(self._search_context_id, similarity_threshold, max_count,
image_id=ImagingAiBase.CLOUD_PATH + "/" + image_name,
folder=folder, storage=storage))
print('Similar images found: ' + str(len(find_response.results)))
print('Similar image id: ' + find_response.results[0].image_id)
print('Similarity: ' + str(find_response.results[0].similarity))
view raw Aspose_Imaging_Cloud_ReverseSearchWebSource.py hosted with ❤ by GitHub

The website-based image source for reverse image search is well elaborated in this example. It includes an additional step of resizing the image to demonstrate the efficiency of API. Image dimensions may differ but the API will produce reliable and accurate results. Following is the screenshot of the output:

As you can notice that the number of similar images, the URL and similarity percentage are shown by the parameters in API response.

Image Deskewing using Aspose.Imaging Cloud SDK for .NET

Images contain a lot of information and image processing has assumed a lot of importance these days. A very common use case is skewed images in scanned PDF documents or often in the images from mobile phone cameras. Aspose.Imaging Cloud API now includes the feature of deskewing the images. You can deskew the images in BMP, GIF, JPEG, JPEG2000, PSD, TIFF, WEBP, and PNG format. Let’s consider a .NET example for deskewing a TIFF image.

using System;
using System.IO;
using Aspose.Imaging.Cloud.Sdk.Api;
using Aspose.Imaging.Cloud.Sdk.Model.Requests;
namespace AsposeImagingCloudSdkExamples
{
/// <summary>
/// Deskew image example.
/// </summary>
/// <seealso cref="AsposeImagingCloudSDKExamples.ImagingBase" />
class DeskewImage : ImagingBase
{
/// <summary>
/// Initializes a new instance of the <see cref="DeskewImage"/> class.
/// </summary>
/// <param name="imagingApi">The imaging API.</param>
public DeskewImage(ImagingApi imagingApi) : base(imagingApi)
{
PrintHeader("Deskew image example:");
}
/// <summary>
/// Gets the name of the example image file.
/// </summary>
/// <value>
/// The name of the example image file.
/// </value>
/// <remarks>
/// Input formats could be one of the following:
/// BMP, GIF, JPEG, JPEG2000, PSD, TIFF, WEBP, PNG
/// </remarks>
protected override string SampleImageFileName => "Sample_05_Scan1_SkewToLeft.tif";
private const string SaveImageFormat = "tif";
/// <summary>
/// Deskews an image from a cloud storage.
/// </summary>
public void DeskewImageFromStorage()
{
Console.WriteLine("Deskew the image from cloud storage");
UploadSampleImageToCloud();
bool resizeProportionally = true;
string bkColor = "white";
string folder = CloudPath; // Input file is saved at the Examples folder in the storage
string storage = null; // We are using default Cloud Storage
var request = new DeskewImageRequest(SampleImageFileName, resizeProportionally, bkColor, folder, storage);
Console.WriteLine($"Call DeskewImage with params: resizeProportionally:{resizeProportionally}, bkColor:{bkColor}");
using (Stream updatedImage = this.ImagingApi.DeskewImage(request))
{
SaveUpdatedSampleImageToOutput(updatedImage, false, SaveImageFormat);
}
Console.WriteLine();
}
/// <summary>
/// Deskew an existing image, and upload updated image to a cloud storage.
/// </summary>
public void DeskewImageAndUploadToStorage()
{
Console.WriteLine("Deskews the image and upload to cloud storage");
UploadSampleImageToCloud();
bool resizeProportionally = true;
string bkColor = null;
string folder = CloudPath; // Input file is saved at the Examples folder in the storage
string storage = null; // We are using default Cloud Storage
var request = new DeskewImageRequest(SampleImageFileName, resizeProportionally, bkColor, folder, storage);
Console.WriteLine($"Call DeskewImage with params: resizeProportionally:{resizeProportionally}, bkColor:{bkColor}");
using (Stream updatedImage = this.ImagingApi.DeskewImage(request))
{
UploadImageToCloud(GetModifiedSampleImageFileName(false, SaveImageFormat), updatedImage);
}
Console.WriteLine();
}
/// <summary>
/// Deskews an image. Image data is passed in a request stream.
/// </summary>
public void CreateDeskewedImageFromRequestBody()
{
Console.WriteLine("Deskews the image from request body");
using (FileStream inputImageStream = File.OpenRead(Path.Combine(ExampleImagesFolder, SampleImageFileName)))
{
bool resizeProportionally = true;
string bkColor = "white";
string storage = null; // We are using default Cloud Storage
string outPath = null; // Path to updated file (if this is empty, response contains streamed image)
var request = new CreateDeskewedImageRequest(inputImageStream, resizeProportionally, bkColor, outPath, storage);
Console.WriteLine($"Call DeskewImage with params: resizeProportionally:{resizeProportionally}, bkColor:{bkColor}");
using (Stream updatedImage = this.ImagingApi.CreateDeskewedImage(request))
{
SaveUpdatedSampleImageToOutput(updatedImage, true, SaveImageFormat);
}
}
Console.WriteLine();
}
}
}
view raw Aspose_Imaging_Cloud_DeskewImages.cs hosted with ❤ by GitHub

This example uploads a sample image to Cloud Storage, deskews it and uploads the updated image to Cloud Storage. Below are the screenshots of input and output TIFF images.

Input TIFF Image

Output TIFF Image (Deskewed)

Aspose.Imaging Cloud SDK for Ruby

Another important addition in SDKs lineup is that we have published Aspose.Imaging Cloud SDK for Ruby. It lets you integrate robust image processing features in your Ruby applications.

We encourage you to try these efficient features of the API and share your experiences with us. Let us know if you have any suggestions or queries. We look forward to hearing back from you via Free Support Forums.

Related Article:

Introducing Aspose.Imaging Cloud V3