def path_to_image(path, image_size, num_channels, interpolation): img = io_ops.read_file(path) img = image_ops.decode_image( img, channels=num_channels, expand_animations=False) img = image_ops.resize_images_v2(img, image_size, method=interpolation) img.set_shape((image_size[0], image_size[1], num_channels)) return img
def predic(request): image = request.FILES['image-file'] fs = FileSystemStorage() imagepath = fs.save(image.name, image) imagepath = fs.url(imagepath) test_image = '.' + imagepath print(test_image) #img = tf.keras.preprocessing.image.load_img(test_image) #x = tf.keras.preprocessing.image.img_to_array(img) #x = tf.data.Dataset.from_tensors(x) img = io_ops.read_file(test_image) img = image_ops.decode_image(img, channels=3, expand_animations=False) img = image_ops.resize_images_v2(img, (256, 256), method='bilinear') img.set_shape((256, 256, 3)) x = tf.data.Dataset.from_tensors(img) x = x.batch(1) #x = x.batch(1) #data = next(iter(x)) #img_path = os.path.join(BASE_DIR, 'media/photo') #img_path = os.path.dirname(img_path) # test_dataset = tf.keras.preprocessing.image_dataset_from_directory( # img_path, color_mode='rgb', batch_size=1) result = model.predict(x) result_ph = np.asarray(result[0][0]) result_normal = np.asarray(result[0][1]) contex = { 'result_ph': result_normal, 'result_normal': result_ph, } return render(request, "app/predict.html", context=contex)
def resize_and_center_cropped_inputs(): """Deterministically resize to shorter side and center crop.""" input_shape = array_ops.shape(inputs) input_height_t = input_shape[1] input_width_t = input_shape[2] ratio_cond = (input_height_t / input_width_t > 1.) # pylint: disable=g-long-lambda resized_height = tf_utils.smart_cond( ratio_cond, lambda: math_ops.cast(self.width * input_height_t / input_width_t, input_height_t.dtype), lambda: self.height) resized_width = tf_utils.smart_cond( ratio_cond, lambda: self.width, lambda: math_ops.cast(self.height * input_width_t / input_height_t, input_width_t.dtype)) # pylint: enable=g-long-lambda resized_inputs = image_ops.resize_images_v2( images=inputs, size=array_ops.stack([resized_height, resized_width])) img_hd_diff = resized_height - self.height img_wd_diff = resized_width - self.width bbox_h_start = math_ops.cast(img_hd_diff / 2, dtypes.int32) bbox_w_start = math_ops.cast(img_wd_diff / 2, dtypes.int32) bbox_begin = array_ops.stack([0, bbox_h_start, bbox_w_start, 0]) bbox_size = array_ops.stack([-1, self.height, self.width, -1]) outputs = array_ops.slice(resized_inputs, bbox_begin, bbox_size) return outputs
def forward(self, *x): x = enforce_singleton(x) low_level_feature = self.backbond1(x) high_level_feature = self.backbond2(low_level_feature) x = self.aspp(high_level_feature) new_shape = list(int_shape(x)[1:]) x = image_ops.resize_images_v2(x, [new_shape[1] * 4, new_shape[0] * 4], method=image_ops.ResizeMethod.BILINEAR) low_level_feature = self.low_level_conv(low_level_feature) x = concate([x, low_level_feature], axis=-1) x = self.decoder(x) new_shape = list(int_shape(x)[1:]) x = image_ops.resize_images_v2(x, [new_shape[1] * 4, new_shape[0] * 4], method=image_ops.ResizeMethod.BILINEAR) return x
def forward(self, x): s = self.pool(x) s = self.activation(self.squeeze(s)) s = tf.sigmoid(self.excite(s)) if self.is_gather_excite: s = image_ops.resize_images_v2( s, x.shape, method=image_ops.ResizeMethod.NEAREST_NEIGHBOR) x = s * x return x
def forward(self, *x): x = enforce_singleton(x) low_level_feature = self.backbond1(x) high_level_feature = self.backbond2(low_level_feature) x = self.aspp(high_level_feature) new_shape = x.shape.as_list()[1:-1] x = image_ops.resize_images_v2( x, (new_shape[0], new_shape[1] * 4, new_shape[2] * 4, new_shape[3]), method=image_ops.ResizeMethod.BILINEAR) low_level_feature = self.low_level_conv(low_level_feature) x = concate([x, low_level_feature], axis=1) x = self.decoder(x) new_shape = x.shape.as_list()[1:-1] x = image_ops.resize_images_v2( x, (new_shape[0], new_shape[1] * 4, new_shape[2] * 4, new_shape[3]), method=image_ops.ResizeMethod.BILINEAR) return x
def load_image(path): print("Query: ") img_disp = PIL.Image.open(path) img_disp.thumbnail((224, 224)) image = io_ops.read_file(path) image = image_ops.decode_image(image, channels=3, expand_animations=False) image = image_ops.resize_images_v2(image, (224, 224), method='bilinear') image.set_shape((224, 224, 3)) image = image.numpy() image = tf.keras.applications.mobilenet_v2.preprocess_input(image) image = np.array([image]) return image
def load_image(path, image_size, num_channels, interpolation, smart_resize=False): """Load an image from a path and resize it.""" img = io_ops.read_file(path) img = image_ops.decode_image( img, channels=num_channels, expand_animations=False) if smart_resize: img = keras_image_ops.smart_resize(img, image_size, interpolation=interpolation) else: img = image_ops.resize_images_v2(img, image_size, method=interpolation) img.set_shape((image_size[0], image_size[1], num_channels)) return img
def random_width_inputs(): """Inputs width-adjusted with random ops.""" inputs_shape = array_ops.shape(inputs) img_hd = inputs_shape[H_AXIS] img_wd = math_ops.cast(inputs_shape[W_AXIS], dtypes.float32) width_factor = self._rng.uniform( shape=[], minval=(1.0 + self.width_lower), maxval=(1.0 + self.width_upper)) adjusted_width = math_ops.cast(width_factor * img_wd, dtypes.int32) adjusted_size = array_ops.stack([img_hd, adjusted_width]) output = image_ops.resize_images_v2( images=inputs, size=adjusted_size, method=self._interpolation_method) original_shape = inputs.shape.as_list() output_shape = original_shape[0:2] + [None] + [original_shape[3]] output.set_shape(output_shape) return output
def random_height_inputs(): """Inputs height-adjusted with random ops.""" inputs_shape = array_ops.shape(inputs) img_hd = math_ops.cast(inputs_shape[H_AXIS], dtypes.float32) img_wd = inputs_shape[W_AXIS] height_factor = self._rng.uniform( shape=[], minval=(1.0 + self.height_lower), maxval=(1.0 + self.height_upper)) adjusted_height = math_ops.cast(height_factor * img_hd, dtypes.int32) adjusted_size = array_ops.stack([adjusted_height, img_wd]) output = image_ops.resize_images_v2( images=inputs, size=adjusted_size, method=self._interpolation_method) original_shape = inputs.shape.as_list() output_shape = [original_shape[0]] + [None] + original_shape[2:4] output.set_shape(output_shape) return output
def testResizeWithPartialStaticShape(self, src_shape, src_sizes, dst_size): channels = src_shape[-1] or 3 images = self.make_image_batch(src_sizes, channels) rt_spec = ragged_tensor.RaggedTensorSpec(src_shape, ragged_rank=images.ragged_rank) expected_shape = [len(src_sizes)] + list(dst_size) + [channels] # Use @tf.function to erase static shape information. @def_function.function(input_signature=[rt_spec]) def do_resize(images): return image_ops.resize_images_v2(images, dst_size) resized_images = do_resize(images) self.assertIsInstance(resized_images, ops.Tensor) self.assertTrue(resized_images.shape.is_compatible_with(expected_shape)) # Check that results for each image matches what we'd get with the # non-batch version of tf.images.resize. for i in range(len(src_sizes)): actual = resized_images[i] expected = image_ops.resize_images_v2(images[i].to_tensor(), dst_size) self.assertAllClose(actual, expected)
def get_image(width, height, want_grayscale, filepath): """Returns an image loaded into an np.ndarray with dims [height, width, (3 or 1)]. Args: width: Width to rescale the image to. height: Height to rescale the image to. want_grayscale: Whether the result should be converted to grayscale. filepath: Path of the image file.. Returns: np.ndarray of shape (height, width, channels) where channels is 1 if want_grayscale is true, otherwise 3. """ with ops.Graph().as_default(): with session.Session(): file_data = io_ops.read_file(filepath) channels = 1 if want_grayscale else 3 image_tensor = image_ops.decode_image(file_data, channels=channels).eval() resized_tensor = image_ops.resize_images_v2( image_tensor, (height, width)).eval() return resized_tensor
def do_resize(images): return image_ops.resize_images_v2(images, dst_size)
def call(self, inputs): outputs = image_ops.resize_images_v2( images=inputs, size=[self.target_height, self.target_width], method=self._interpolation_method) return outputs
def testBadRank(self): rt = ragged_tensor.RaggedTensor.from_tensor(array_ops.zeros([5, 5, 3])) with self.assertRaisesRegex(ValueError, 'rank must be 4'): image_ops.resize_images_v2(rt, [10, 10])
def smart_resize(x, size, interpolation='bilinear'): """Resize images to a target size without aspect ratio distortion. TensorFlow image datasets typically yield images that have each a different size. However, these images need to be batched before they can be processed by Keras layers. To be batched, images need to share the same height and width. You could simply do: ```python size = (200, 200) ds = ds.map(lambda img: tf.image.resize(img, size)) ``` However, if you do this, you distort the aspect ratio of your images, since in general they do not all have the same aspect ratio as `size`. This is fine in many cases, but not always (e.g. for GANs this can be a problem). Note that passing the argument `preserve_aspect_ratio=True` to `resize` will preserve the aspect ratio, but at the cost of no longer respecting the provided target size. Because `tf.image.resize` doesn't crop images, your output images will still have different sizes. This calls for: ```python size = (200, 200) ds = ds.map(lambda img: smart_resize(img, size)) ``` Your output images will actually be `(200, 200)`, and will not be distorted. Instead, the parts of the image that do not fit within the target size get cropped out. The resizing process is: 1. Take the largest centered crop of the image that has the same aspect ratio as the target size. For instance, if `size=(200, 200)` and the input image has size `(340, 500)`, we take a crop of `(340, 340)` centered along the width. 2. Resize the cropped image to the target size. In the example above, we resize the `(340, 340)` crop to `(200, 200)`. Args: x: Input image (as a tensor or NumPy array). Must be in format `(height, width, channels)`. size: Tuple of `(height, width)` integer. Target size. interpolation: String, interpolation to use for resizing. Defaults to `'bilinear'`. Supports `bilinear`, `nearest`, `bicubic`, `area`, `lanczos3`, `lanczos5`, `gaussian`, `mitchellcubic`. Returns: Array with shape `(size[0], size[1], channels)`. If the input image was a NumPy array, the output is a NumPy array, and if it was a TF tensor, the output is a TF tensor. """ if len(size) != 2: raise ValueError('Expected `size` to be a tuple of 2 integers, ' 'but got: %s' % (size,)) img = ops.convert_to_tensor_v2_with_dispatch(x) if img.shape.rank is not None: if img.shape.rank != 3: raise ValueError( 'Expected an image array with shape `(height, width, channels)`, but ' 'got input with incorrect rank, of shape %s' % (img.shape,)) shape = array_ops.shape(img) height, width = shape[0], shape[1] target_height, target_width = size crop_height = math_ops.cast( math_ops.cast(width * target_height, 'float32') / target_width, 'int32') crop_width = math_ops.cast( math_ops.cast(height * target_width, 'float32') / target_height, 'int32') # Set back to input height / width if crop_height / crop_width is not smaller. crop_height = math_ops.minimum(height, crop_height) crop_width = math_ops.minimum(width, crop_width) crop_box_hstart = math_ops.cast( math_ops.cast(height - crop_height, 'float32') / 2, 'int32') crop_box_wstart = math_ops.cast( math_ops.cast(width - crop_width, 'float32') / 2, 'int32') crop_box_start = array_ops.stack([crop_box_hstart, crop_box_wstart, 0]) crop_box_size = array_ops.stack([crop_height, crop_width, -1]) img = array_ops.slice(img, crop_box_start, crop_box_size) img = image_ops.resize_images_v2( images=img, size=size, method=interpolation) if isinstance(x, np.ndarray): return img.numpy() return img
def do_resize(images, new_size): return image_ops.resize_images_v2(images, new_size)