If you haven’t set up the SDK yet, make sure to go through those directions first. You’ll need to add the Core library to the app before using the specific feature API or custom model. Follow iOS setup or Android setup directions.

Fritz provides an Android API that you can use to transform images or live video into beautiful works of art. You can choose to stylize an image from the photo gallery or transform live video captured by the device’s camera. Follow these simple instructions in order to bring style transfer to your app in no time.

Use Painting Styles

Follow these directions in order to apply one of the prebuilt styles to your app.

1. Add the dependencies via Gradle

Add our repository in order to download the Vision API:

repositories {
    maven { url "" }

Include the dependencies in app/build.gradle:

dependencies {
    implementation 'ai.fritz:core:3.3.+'
    implementation 'ai.fritz:vision:3.3.+'

(Optional include model in your app) To include Style Transfer model with your build, then you’ll need to add the dependency as shown below. Note: This includes the model with your app when you publish it to the play store and will increase your app size.

You’ll also need to specity aaptOptions in order to prevent compressing TensorFlow Lite models.

android {
  aaptOptions {
    noCompress "tflite"

dependencies {
  implementation 'ai.fritz:vision-style-painting-models:3.3.+'

Now you’re ready to transform images with the Style Transfer API.

2. Get a style predictor

In order to use the predictor, the on-device model must first be loaded. If you followed the Optional step above and included the ai.fritz:vision-image-label-model dependency, you can get a predictor to use immediately:


Use one of the included on-device models for the style you’d like to use:

// For included on-device models
import ai.fritz.core.FritzOnDeviceModel;
// ...

FritzOnDeviceModel styleOnDeviceModel = PaintingStyles.STARRY_NIGHT;
FritzVisionStylePredictor predictor = FritzVision.StyleTransfer.getPredictor(styleOnDeviceModel);

If you did not include the on-device model with your app, you’ll have to load the model before you can get a predictor. To do that, you’ll use StyleManagedModel and call FritzVision.StyleTransfer.loadPredictor to start the model download.


Use one of the managed models for the style you’d like to use:

// For models to download
import ai.fritz.core.FritzManagedModel;
// ...

FritzVisionLabelPredictor predictor;

FritzManagedModel managedModel = PaintingManagedModels.STARRY_NIGHT_MANAGED_MODEL;
FritzVision.StyleTransfer.loadPredictor(managedModel, new PredictorStatusListener<FritzVisionStylePredictor>() {
    public void onPredictorReady(FritzVisionStylePredictor stylePredictor) {
        Log.d(TAG, "Style Transfer predictor is ready");
        predictor = stylePredictor;

3. Create a FritzVisionImage from an image or a video stream

To create a FritzVisionImage from a Bitmap:

FritzVisionImage visionImage = FritzVisionImage.fromBitmap(bitmap);

To create a FritzVisionImage from a media.Image object when capturing the result from a camera, first determine the orientation of the image. This will rotate the image to account for device rotation and the orientation of the camera sensor.

// Get the system service for the camera manager
final CameraManager manager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);

// Gets the first camera id
String cameraId = manager.getCameraIdList().get(0);

// Determine the rotation on the FritzVisionImage from the camera orientaion and the device rotation.
// "this" refers to the calling Context (Application, Activity, etc)
int imageRotationFromCamera = FritzVisionOrientation.getImageRotationFromCamera(this, cameraId);

Finally, create the FritzVisionImage object with the rotation

FritzVisionImage visionImage = FritzVisionImage.fromMediaImage(image, imageRotationFromCamera);

4. Run prediction on FritzVisionImage

Apply a style to your FritzVisionImage to get a FritzVisionStyleResult object.

FritzVisionStyleResult styleResult = stylePredictor.predict(visionImage);

The predict method returns back a FritzVisionStyleResult object that contains the following methods:

Method Description
FritzVisionImage getOriginalImage() Get the original image passed into the predict method.
Bitmap toBitmap() Get the stylized image as a bitmap with the same dimensions as the model input resolution.
Bitmap toBitmap(Size scaleToSize) Get the stylized image as a bitmap with the specified dimensions. (Note: This will add some processing time to resize the output)
FritzVisionImage getStyledImage() Get the styled image after it’s been passed through the model.
void drawVisionImage(Canvas canvas) Draws the original image passed in to the predict method.
void drawVisionImage(Canvas canvas, Size canvasSize) Draws the original image scaled up to the target canvas size. E.g Your original image was 512x512 but you’d like to stretch it to fit a canvas size of 1024x1024.
void drawToCanvas(Canvas canvas) Draw the styled image to the canvas.
void drawToCanvas(Canvas canvas, Size canvasSize) Draw the styled image and scale it up to the specified size.

5. Access the Style Result

FritzVisionStyleResult contains several convenience methods to help draw the image.

Drawing the styled image as the original size

Using a canvas to display the result:

// Draw the result to the canvas (same size as the input image)

Using an ImageView to display the result:

// Set the Bitmap for the image view

Drawing the styled image for a target size

Using a canvas to display the result:

// Target canvas size
Size targetSize = new Size(2048, 2048);

// Draw the result and scale the image to a specific size (while maintaining the aspect ratio)
styleResult.drawToCanvas(canvas, targetSize);

Using an ImageView to display the result:

// Target canvas size
Size targetSize = new Size(2048, 2048);

Bitmap bitmap = styleResult.getResultBitmap(targetSize);

// Set the scaled bitmap

Accessing the bitmap directly

// Access the original bitmap
FritzVisionImage originalVisionImage = styleResult.getOriginalImage();
Bitmap originalBitmap = originalVisionImage.getBitmap();

// Acccess the styled bitmap
Bitmap styledBitmap = styleResult.getResultBitmap();

Configure Prediction

Before running style transfer, you can configure the prediction with a FritzVisionStylePredictorOptions object.


FritzVisionCropAndScale.SCALE_TO_FIT (default)

Crop and Scale option for how to resize and crop the image for the model


1 (default)

The number of threads to use to process the result.

Crop and scale option

By setting FritzVisionCropAndScale on FritzVisionStylePredictorOptions, you can control preprocessing on the image.

There are 2 crop and scale options available:

  • FritzVisionCropAndScale.SCALE_TO_FIT (default) - Resizes the original image to fit the size of the model input while maintaining the aspect ratio. After inference, the output is scaled back to the original aspect ratio. (e.g for a model input size of 384x384, scale a 600x400 image down to fit the model size. After the model runs inference, scale the output results to match the original 600x400 aspect ratio).
  • FritzVisionCropAndScale.CENTER_CROP - Run prediction on a center cropped section of the original image passed into the predict method. (e.g if the original image is 600x400, the predictor will run on a 400x400 image)

Example usage:

FritzVisionStylePredictorOptions options = new FritzVisionStylePredictorOptions.Builder()
predictor = FritzVision.StyleTransfer.getPredictor(onDeviceModel, options);

Num Threads

Set the number of threads to use for model inference.

Example usage:

FritzVisionStylePredictorOptions options = new FritzVisionStylePredictorOptions.Builder()
predictor = FritzVision.StyleTransfer.getPredictor(onDeviceModel, options);

How to customize

If you want to train and use your own custom style transfer model, follow the open source training template on Google Colab.

For a full tutorial on training your custom model, take a look at this blog post on Heartbeat.

After you’ve finished training your model, follow these steps to add it to your Android app.

  1. Add your optimized TensorFlow Mobile protobuf file (.pb) that contains your custom trained style transfer model to your app’s assets folder.
  2. Upload your custom model to Fritz’s webapp.
  3. Use the model id from Step 2 and initialize a predictor to use in your app.
FritzOnDeviceModel onDeviceModel = new FritzOnDeviceModel("custom_style_transfer_graph.pb", "<Your model id from step 2>", 1);
predictor = FritzVision.StyleTransfer.getPredictor(onDeviceModel);
  1. Use your predictor the same way as described above with predictor.predict(visionImage).