Skip to content

General example

Otary unifies geometry and image processing in a single API.

You can construct geometric entities, render them onto an image, and apply image-processing transformations, all within the same workflow, without switching between libraries.

Image and Geometry at once

Because visual output is the best way to verify a transformation, the example below walks through this end-to-end.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
im = ot.Image.from_file("../tests/data/vision/example2/sample-otary-img1.pdf")

polygon_array = np.array(
    [[60, 200], [130, 130], [270, 130], [270, 300], [250, 500], [60, 500]]
)

polygon = ot.Polygon(polygon_array)
aabb = polygon.aabb().expand(1.1) # Axis Aligned Bounding Box (AABB)

im.copy().draw_polygons(
    polygons=[polygon, aabb],
    render=ot.PolygonsRender(colors=["red", "blue"], thickness=2),
).show()

Advanced Image Manipulation

Suppose you what to manipulate the image in a given part of it. Here is an example of what you could do.

14
15
16
17
18
im.crop_from_axis_aligned_bbox(aabb, copy=True) \
  .threshold_sauvola(k=0.1) \
  .resize(factor=2, copy=True) \
  .rotate(30, is_degree=True, is_clockwise=True, fill_value=200) \
  .add_border(5, fill_value=0)

The previous code does the following:

  1. Crop the image from the AABB
  2. Apply a threshold to binarize the image. It is now composed of only two values: 0 & 255
  3. Resize the image by a factor of 2
  4. Rotate the image by 30 degrees clockwise
  5. Add a black border to the image

And here is the result:

Otary is designed to be interactive and user-friendly, ideal for Jupyter notebooks and live exploration.

Enhanced Interactivity

In a Jupyter notebook, you can easily test and iterate on transformations by simply commenting part of the code as you need it and quickly see the result.

im.crop_from_axis_aligned_bbox(aabb, copy=True) \
.threshold_sauvola(k=0.1) \
# .resize(factor=2, copy=True) \
# .rotate(30, is_degree=True, is_clockwise=True, fill_value=200) \
.add_border(5, fill_value=0)

Crop image efficiently

Some methods (all the cropping methods, some morphology methods like resize, etc...) have a boolean copy parameter.

By default, the copy parameter is set to False which means that the original image is modified and then returned. This is the default behaviour of all the methods in the Otary library.

However, when copy is set to True, a new Image object is returned and the original image is not modified. This is useful when you want to create a new image after the transformation without modifying the original image.

Consider an example where you want to crop an image:

Wrong way of cropping and preserving the original image

This approach works but can be considerably slower especially when the image is large because you first copy the image and then crop it.

import otary as ot

im = ot.Image.from_file(filepath="path/to/file/image")

im_crop = im.copy().crop(x0=50, y0=50, x1=450, y1=450)

This would instead be the correct way to crop and preserve the original image:

Good way of cropping and preserving the original image

Here we just create a new image based on the cropped part, not the entire original image which is considerably faster on large images.

import otary as ot

im = ot.Image.from_file(filepath="path/to/file/image")

im_crop = im.crop(x0=50, y0=50, x1=450, y1=450, copy=True)