[question] how to use dali resize in "not_larger" mode?

[pokerc]

Hi there, for example, here i have two images, image_a with shape (500,500,3) and image_b with shape (1100,750,3).
I use "not_larger" mode in ops.Resize, like below:
resize = ops.Resize(device='cpu', mode="not_larger", size=960)
and the output shapes are image_a with shape (960,960,3) and image_b with shape (960,655,3) .
I want to know where there is any method to keep the origin shape when the longer size in one image is smaller than 960.
In other words i want to resize image_b to (960,655,3) because its too larger, but i want to keep image_a as the shape it used to be, and that is (500,500,3).

[JanuszL]

The Resize operator itself doesn't have such functionality. However, you can try using conditional execution to and selectively resize images that are above a certain threshold. You can obtain shape using Shapes operator or PeekImageShape.

[pokerc]

The Resize operator itself doesn't have such functionality. However, you can try using conditional execution to and selectively resize images that are above a certain threshold. You can obtain shape using Shapes operator or PeekImageShape.

Thanks for you suggestion, but I have tried multiplexing but got error like this:

It seems that case and neg_case should be the same shape.
my pipeline is:

class DaliDecodePipeline(Pipeline):

    def __init__(self, batch_size, num_threads, device_id, data_gen):
        super(DaliDecodePipeline, self).__init__(batch_size, num_threads, device_id, seed=12, prefetch_queue_depth=1)
        self.input = ops.ExternalSource(source=data_gen)
        self.decode = ops.ImageDecoder(device='mixed', output_type=types.BGR)
        self.get_shape = ops.Shapes(device="gpu")
        self.resize = ops.Resize(device="gpu", mode="not_larger", size=960)
        # self.cast = ops.Cast(dtype=types.DALIDataType.BOOL)
    
    def define_graph(self):
        img_bin = self.input()
        images = self.decode(img_bin)
        # images_shape = self.get_shape(images)
        images_resized = self.resize(images)
        # images_resized_shape = self.get_shape(images_resized)
        condition_out = images * True + images_resized * False
        return condition_out

Any more suggestion?

[JanuszL]

You may try something like this:

from nvidia.dali.pipeline import Pipeline
import nvidia.dali.fn as fn
import nvidia.dali.types as types
import numpy as np
import nvidia.dali.math as math

pipe = Pipeline(batch_size=4, num_threads=3, device_id=0)
images = fn.external_source(source = data_gen)
shape = fn.peek_image_shape(images)
max_dim = fn.reductions.max(shape)
scale = math.min(max_dim, 960)
images = fn.image_decoder(images, device='mixed')
images = fn.resize(images, size=fn.cast(scale, dtype=types.FLOAT), mode="not_larger")
pipe.set_outputs(images)
pipe.build()
dali_out = pipe.run()

The only downside is that even if the scale is the same at the resize output as in the input image is still interpolated.

[pokerc]

I will have a try later. Thanks!