react-native-photo-video-editor 0.1.0 → 0.2.0

package/android/src/main/java/com/photovideoeditor/photo/export/PhotoExporter.kt

@@ -12,6 +12,7 @@ import com.photovideoeditor.photo.render.PhotoAdjustmentRenderer
 import com.photovideoeditor.photo.render.PhotoAdjustments
 import com.photovideoeditor.photo.render.PhotoLayer
 import com.photovideoeditor.photo.render.PhotoLayerRenderer
+import com.photovideoeditor.photo.render.PhotoTransformRenderer
 import com.photovideoeditor.photo.render.PhotoTransformState
 import org.json.JSONObject
 import java.io.File
@@ -68,11 +69,11 @@ object PhotoExporter {
       ?: throw PhotoExportException("E_OUT_OF_MEMORY", "The photo is too large to process on this device.")
 
     val upright = applyExifOrientation(decoded, exifOrientation)
-    val transformed = applyTransform(upright, transform)
+    val transformed = PhotoTransformRenderer.transform(upright, transform)
     val adjusted = PhotoAdjustmentRenderer.apply(transformed, adjustments)
-    val layered = PhotoLayerRenderer.render(adjusted, layers) { uri -> resolveImageUri(context, uri) }
-    val cropped = cropBitmap(layered, transform)
-    val resized = resizeToFit(cropped, maxWidth, maxHeight)
+    val cropped = PhotoTransformRenderer.crop(adjusted, transform)
+    val layered = PhotoLayerRenderer.render(cropped, layers) { uri -> resolveImageUri(context, uri) }
+    val resized = resizeToFit(layered, maxWidth, maxHeight)
 
     val format = exportOptions?.optString("imageFormat", "jpeg")?.lowercase() ?: "jpeg"
     val quality = qualityFor(exportOptions?.optString("quality", "high") ?: "high")
@@ -93,9 +94,9 @@ object PhotoExporter {
     if (decoded !== upright) decoded.recycle()
     if (upright !== transformed) upright.recycle()
     if (transformed !== adjusted) transformed.recycle()
-    if (adjusted !== layered) adjusted.recycle()
-    if (layered !== cropped) layered.recycle()
-    if (cropped !== resized) cropped.recycle()
+    if (adjusted !== cropped) adjusted.recycle()
+    if (cropped !== layered) cropped.recycle()
+    if (layered !== resized) layered.recycle()
 
     return PhotoExportResult(
       uri = Uri.fromFile(outputFile).toString(),
@@ -130,22 +131,6 @@ object PhotoExporter {
     return Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true)
   }
 
-  private fun applyTransform(bitmap: Bitmap, transform: PhotoTransformState): Bitmap {
-    if (transform.rotationDegrees == 0 && transform.straightenDegrees == 0f) return bitmap
-    return Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, transform.toMatrix(), true)
-  }
-
-  private fun cropBitmap(bitmap: Bitmap, transform: PhotoTransformState): Bitmap {
-    if (transform.cropLeft <= 0f && transform.cropTop <= 0f && transform.cropRight >= 1f && transform.cropBottom >= 1f) {
-      return bitmap
-    }
-    val left = (transform.cropLeft * bitmap.width).roundToInt().coerceIn(0, bitmap.width - 1)
-    val top = (transform.cropTop * bitmap.height).roundToInt().coerceIn(0, bitmap.height - 1)
-    val right = (transform.cropRight * bitmap.width).roundToInt().coerceIn(left + 1, bitmap.width)
-    val bottom = (transform.cropBottom * bitmap.height).roundToInt().coerceIn(top + 1, bitmap.height)
-    return Bitmap.createBitmap(bitmap, left, top, right - left, bottom - top)
-  }
-
   private fun resizeToFit(bitmap: Bitmap, maxWidth: Int?, maxHeight: Int?): Bitmap {
     if (maxWidth == null && maxHeight == null) return bitmap
     val widthLimit = maxWidth ?: bitmap.width

package/android/src/main/java/com/photovideoeditor/photo/render/CropGeometry.kt

@@ -0,0 +1,71 @@
+package com.photovideoeditor.photo.render
+
+import kotlin.math.abs
+import kotlin.math.cos
+import kotlin.math.sin
+
+/** Resolution-independent crop constraints shared by gestures and rendering. */
+object CropGeometry {
+  data class Rect(val left: Float, val top: Float, val right: Float, val bottom: Float) {
+    val width get() = right - left
+    val height get() = bottom - top
+  }
+  enum class Handle { MOVE, TOP, RIGHT, BOTTOM, LEFT, TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT, BOTTOM_RIGHT }
+
+  fun fillScale(width: Float, height: Float, degrees: Float): Float {
+    val radians = Math.toRadians(degrees.toDouble())
+    val c = abs(cos(radians)).toFloat(); val s = abs(sin(radians)).toFloat()
+    return maxOf(c + height / width * s, c + width / height * s)
+  }
+
+  fun fit(bounds: Rect, ratio: Float?): Rect {
+    if (ratio == null || ratio <= 0) return bounds
+    val width = minOf(bounds.width, bounds.height * ratio)
+    val height = width / ratio
+    val x = (bounds.left + bounds.right - width) / 2
+    val y = (bounds.top + bounds.bottom - height) / 2
+    return Rect(x, y, x + width, y + height)
+  }
+
+  /** Keeps the opposite edge/corner anchored; clamps motion instead of shifting a resized box. */
+  fun resize(r: Rect, bounds: Rect, handle: Handle, dx: Float, dy: Float, ratio: Float?, minimum: Float): Rect {
+    if (handle == Handle.MOVE) {
+      val x = dx.coerceIn(bounds.left - r.left, bounds.right - r.right)
+      val y = dy.coerceIn(bounds.top - r.top, bounds.bottom - r.bottom)
+      return Rect(r.left + x, r.top + y, r.right + x, r.bottom + y)
+    }
+    val left = handle in listOf(Handle.LEFT, Handle.TOP_LEFT, Handle.BOTTOM_LEFT)
+    val right = handle in listOf(Handle.RIGHT, Handle.TOP_RIGHT, Handle.BOTTOM_RIGHT)
+    val top = handle in listOf(Handle.TOP, Handle.TOP_LEFT, Handle.TOP_RIGHT)
+    val bottom = handle in listOf(Handle.BOTTOM, Handle.BOTTOM_LEFT, Handle.BOTTOM_RIGHT)
+    var l = r.left + if (left) dx else 0f
+    var t = r.top + if (top) dy else 0f
+    var rr = r.right + if (right) dx else 0f
+    var b = r.bottom + if (bottom) dy else 0f
+    if (ratio != null && ratio > 0) {
+      if ((left || right) && (top || bottom)) {
+        val deltaW = if (left) -dx else dx
+        val deltaH = if (top) -dy else dy
+        val width = r.width + if (abs(deltaW) > abs(deltaH * ratio)) deltaW else deltaH * ratio
+        if (left) l = r.right - width else rr = r.left + width
+        if (top) t = r.bottom - width / ratio else b = r.top + width / ratio
+      } else if (left || right) {
+        val height = (rr - l) / ratio
+        t = (r.top + r.bottom - height) / 2; b = t + height
+      } else {
+        val width = (b - t) * ratio
+        l = (r.left + r.right - width) / 2; rr = l + width
+      }
+    }
+    // All constraints are linear along the drag; interpolation preserves the ratio and anchor.
+    var fraction = 1f
+    fun limit(before: Float, after: Float, minimumValue: Float) {
+      if (after < minimumValue && after < before) fraction = minOf(fraction, ((before - minimumValue) / (before - after)).coerceIn(0f, 1f))
+    }
+    limit(r.left, l, bounds.left); limit(r.top, t, bounds.top)
+    limit(-r.right, -rr, -bounds.right); limit(-r.bottom, -b, -bounds.bottom)
+    limit(r.width, rr - l, minOf(minimum, r.width)); limit(r.height, b - t, minOf(minimum, r.height))
+    return Rect(r.left + (l - r.left) * fraction, r.top + (t - r.top) * fraction,
+      r.right + (rr - r.right) * fraction, r.bottom + (b - r.bottom) * fraction)
+  }
+}

package/android/src/main/java/com/photovideoeditor/photo/render/OverlayGeometry.kt

@@ -2,6 +2,16 @@ package com.photovideoeditor.photo.render
 
 /** Pure coordinate mapping shared by preview and export renderers. */
 object OverlayGeometry {
+  /** New sticker width is 30% of media width; persisted layers keep their existing scale. */
+  fun initialStickerScale(width: Float, height: Float): Float =
+    if (width > 0 && height > 0) 0.3f * width / (0.18f * minOf(width, height)) else 0.3f / 0.18f
+
+  fun stickerSize(shortSide: Float, aspectRatio: Float): Pair<Float, Float> {
+    val width = shortSide * 0.18f
+    val aspect = aspectRatio.takeIf { it.isFinite() && it > 0f } ?: 1f
+    return width to (width / aspect)
+  }
+
   data class Transform(
     val centerX: Float,
     val centerY: Float,
@@ -11,6 +21,32 @@ object OverlayGeometry {
     val shortSide: Float,
   )
 
+  /**
+   * How to size the bitmap that [PhotoLayerRenderer] composites overlays onto for a
+   * [frameWidth]x[frameHeight] output frame, plus the scale a compositor must apply to that bitmap
+   * for it to cover the frame exactly.
+   *
+   * [PhotoLayerRenderer] works in coordinates normalized to the bitmap it is handed, so the invariant
+   * every caller must preserve is `width * scaleX == frameWidth` (and likewise for height): a bitmap
+   * that ends up covering less than the full frame shrinks every layer and pulls it toward the frame
+   * centre, which is precisely how exports came to disagree with the preview.
+   *
+   * [maxEdgePx] bounds the allocation for high-resolution outputs; the returned scale compensates for
+   * whatever downscale that forced, so geometry is identical at every resolution and only sharpness
+   * varies.
+   */
+  data class CanvasPlan(val width: Int, val height: Int, val scaleX: Float, val scaleY: Float)
+
+  fun canvasPlan(frameWidth: Int, frameHeight: Int, maxEdgePx: Float): CanvasPlan {
+    val safeWidth = frameWidth.coerceAtLeast(2)
+    val safeHeight = frameHeight.coerceAtLeast(2)
+    val fit = minOf(1f, maxEdgePx / maxOf(safeWidth, safeHeight))
+    val width = (safeWidth * fit).toInt().coerceAtLeast(2)
+    val height = (safeHeight * fit).toInt().coerceAtLeast(2)
+    // Divide by the rounded size actually allocated, not `fit`, so rounding cannot reintroduce drift.
+    return CanvasPlan(width, height, safeWidth.toFloat() / width, safeHeight.toFloat() / height)
+  }
+
   fun map(layer: PhotoLayer, frameWidth: Int, frameHeight: Int): Transform = Transform(
     centerX = layer.x * frameWidth,
     centerY = layer.y * frameHeight,

package/android/src/main/java/com/photovideoeditor/photo/render/PhotoEditSession.kt

@@ -42,11 +42,7 @@ class PhotoEditSession(private val context: Context, sourceUri: String, maxPrevi
     val base = baseBitmap ?: return null
     val key = Pair(state, adjustments)
     cachedBaseBitmap?.let { if (cachedKey == key) return it }
-    val transformed = if (state.rotationDegrees == 0 && state.straightenDegrees == 0f) {
-      base
-    } else {
-      Bitmap.createBitmap(base, 0, 0, base.width, base.height, state.toMatrix(), true)
-    }
+    val transformed = PhotoTransformRenderer.transform(base, state)
     val adjusted = PhotoAdjustmentRenderer.apply(transformed, adjustments)
     cachedBaseBitmap = adjusted
     cachedKey = key
@@ -54,8 +50,10 @@ class PhotoEditSession(private val context: Context, sourceUri: String, maxPrevi
   }
 
   /** Renders rotate/straighten + adjustments + layers — the crop overlay draws the crop live on top of this. */
-  fun renderPreview(): Bitmap? {
-    val base = computeBase() ?: return null
+  fun renderPreview(cropping: Boolean = false): Bitmap? {
+    val transformed = computeBase() ?: return null
+    if (cropping) return transformed
+    val base = PhotoTransformRenderer.crop(transformed, state)
     val layers = layerStack.layers
     cachedPreviewBitmap?.let { cached ->
       if (cachedPreviewBase === base && cachedPreviewLayerRevision == layerStack.revision) return cached

package/android/src/main/java/com/photovideoeditor/photo/render/PhotoFilterPresets.kt

@@ -2,63 +2,93 @@ package com.photovideoeditor.photo.render
 
 import android.graphics.ColorMatrix
 
-/** A small set of original, neutrally named preset filters (no third-party looks or names copied). */
+/**
+ * Original, neutrally named preset filters (no third-party looks or names copied).
+ *
+ * Every preset is expressed as the same four knobs the renderer already supports, so a preset can
+ * never be a button that does nothing: set [saturation], scale RGB by [scale], then add the
+ * per-channel offsets. `PhotoFilterPresets.swift` mirrors this table field-for-field — add presets to
+ * both or neither, or the two platforms will render different looks for the same id.
+ */
+data class PhotoFilterRecipe(
+  val saturation: Float,
+  val scale: Float,
+  val redOffset: Float,
+  val greenOffset: Float,
+  val blueOffset: Float
+)
+
 object PhotoFilterPresets {
-  val PRESET_IDS = listOf("mono", "noir", "fade", "chrome", "warmth")
+  /** Display order in the carousel. "Original" (no preset) is prepended by the UI, not listed here. */
+  val PRESET_IDS = listOf(
+    "vivid", "vividWarm", "vividCool",
+    "warmth", "cool",
+    "natural", "soft", "fade",
+    "mono", "noir", "silvertone",
+    "vintage", "sepia", "retro",
+    "dramatic", "dramaticWarm", "dramaticCool"
+  )
+
+  private val recipes = mapOf(
+    "vivid" to PhotoFilterRecipe(1.45f, 1.05f, 0f, 0f, 0f),
+    "vividWarm" to PhotoFilterRecipe(1.45f, 1.05f, 12f, 4f, -10f),
+    "vividCool" to PhotoFilterRecipe(1.45f, 1.05f, -8f, 0f, 14f),
+    "warmth" to PhotoFilterRecipe(1.05f, 1f, 18f, 6f, -12f),
+    "cool" to PhotoFilterRecipe(1.05f, 1f, -12f, 0f, 18f),
+    "natural" to PhotoFilterRecipe(1.15f, 1.02f, 2f, 2f, 0f),
+    "soft" to PhotoFilterRecipe(0.9f, 0.96f, 14f, 12f, 12f),
+    "fade" to PhotoFilterRecipe(1f, 0.9f, 25f, 25f, 25f),
+    "mono" to PhotoFilterRecipe(0f, 1f, 0f, 0f, 0f),
+    "noir" to PhotoFilterRecipe(0f, 1.3f, -40f, -40f, -40f),
+    "silvertone" to PhotoFilterRecipe(0f, 1.1f, -6f, -2f, 10f),
+    "vintage" to PhotoFilterRecipe(0.6f, 0.95f, 24f, 12f, -6f),
+    "sepia" to PhotoFilterRecipe(0f, 1f, 38f, 20f, -14f),
+    "retro" to PhotoFilterRecipe(0.75f, 0.92f, 20f, 6f, 14f),
+    "dramatic" to PhotoFilterRecipe(1.2f, 1.25f, -28f, -28f, -28f),
+    "dramaticWarm" to PhotoFilterRecipe(1.2f, 1.25f, -14f, -26f, -38f),
+    "dramaticCool" to PhotoFilterRecipe(1.2f, 1.25f, -38f, -28f, -12f),
+    // Retained so photos saved with an earlier preset id still render; not offered in the carousel.
+    "chrome" to PhotoFilterRecipe(1.4f, 1.1f, 0f, 0f, 0f)
+  )
 
   fun labelFor(id: String): String = when (id) {
+    "vivid" -> "Vivid"
+    "vividWarm" -> "Vivid Warm"
+    "vividCool" -> "Vivid Cool"
+    "warmth" -> "Warm"
+    "cool" -> "Cool"
+    "natural" -> "Natural"
+    "soft" -> "Soft"
+    "fade" -> "Fade"
     "mono" -> "Mono"
     "noir" -> "Noir"
-    "fade" -> "Fade"
+    "silvertone" -> "Silvertone"
+    "vintage" -> "Vintage"
+    "sepia" -> "Sepia"
+    "retro" -> "Retro"
+    "dramatic" -> "Dramatic"
+    "dramaticWarm" -> "Dramatic Warm"
+    "dramaticCool" -> "Dramatic Cool"
     "chrome" -> "Chrome"
-    "warmth" -> "Warmth"
     else -> id
   }
 
-  fun matrixFor(id: String): ColorMatrix? = when (id) {
-    "mono" -> ColorMatrix().apply { setSaturation(0f) }
-    "noir" -> ColorMatrix().apply {
-      setSaturation(0f)
-      postConcat(
-        ColorMatrix(
-          floatArrayOf(
-            1.3f, 0f, 0f, 0f, -40f,
-            0f, 1.3f, 0f, 0f, -40f,
-            0f, 0f, 1.3f, 0f, -40f,
-            0f, 0f, 0f, 1f, 0f
-          )
-        )
-      )
-    }
-    "fade" -> ColorMatrix(
-      floatArrayOf(
-        0.9f, 0f, 0f, 0f, 25f,
-        0f, 0.9f, 0f, 0f, 25f,
-        0f, 0f, 0.9f, 0f, 25f,
-        0f, 0f, 0f, 1f, 0f
-      )
-    )
-    "chrome" -> ColorMatrix().apply {
-      setSaturation(1.4f)
+  fun recipeFor(id: String): PhotoFilterRecipe? = recipes[id]
+
+  fun matrixFor(id: String): ColorMatrix? {
+    val recipe = recipes[id] ?: return null
+    return ColorMatrix().apply {
+      setSaturation(recipe.saturation)
       postConcat(
         ColorMatrix(
           floatArrayOf(
-            1.1f, 0f, 0f, 0f, 0f,
-            0f, 1.1f, 0f, 0f, 0f,
-            0f, 0f, 1.1f, 0f, 0f,
+            recipe.scale, 0f, 0f, 0f, recipe.redOffset,
+            0f, recipe.scale, 0f, 0f, recipe.greenOffset,
+            0f, 0f, recipe.scale, 0f, recipe.blueOffset,
             0f, 0f, 0f, 1f, 0f
           )
         )
       )
     }
-    "warmth" -> ColorMatrix(
-      floatArrayOf(
-        1f, 0f, 0f, 0f, 18f,
-        0f, 1f, 0f, 0f, 6f,
-        0f, 0f, 1f, 0f, -12f,
-        0f, 0f, 0f, 1f, 0f
-      )
-    )
-    else -> null
   }
 }

package/android/src/main/java/com/photovideoeditor/photo/render/PhotoLayer.kt

@@ -3,7 +3,7 @@ package com.photovideoeditor.photo.render
 import android.graphics.Color
 import java.util.UUID
 
-enum class LayerType { TEXT, STICKER, OVERLAY }
+enum class LayerType { TEXT, STICKER, OVERLAY, DRAWING }
 
 /**
  * A single non-destructive overlay layer (text, sticker, or uploaded image
@@ -33,6 +33,10 @@ data class PhotoLayer(
   // Overlay (uploaded image)
   var overlayUri: String? = null,
   var overlayAspectRatio: Float? = null,
+  // Drawing (points are normalized offsets from x/y)
+  var drawColor: Int = Color.RED,
+  var drawStrokeWidth: Float = 0.012f,
+  var drawPoints: List<Pair<Float, Float>> = emptyList(),
   // Timing (video overlays only; ignored for photo layers). endMs <= 0 means "to end of video".
   var startMs: Long = 0L,
   var endMs: Long = 0L

package/android/src/main/java/com/photovideoeditor/photo/render/PhotoLayerRenderer.kt

@@ -3,6 +3,7 @@ package com.photovideoeditor.photo.render
 import android.graphics.Bitmap
 import android.graphics.Canvas
 import android.graphics.Paint
+import android.graphics.Path
 import android.graphics.RectF
 import android.text.TextPaint
 
@@ -41,6 +42,7 @@ object PhotoLayerRenderer {
         LayerType.TEXT -> drawText(canvas, layer, geometry.shortSide, alpha)
         LayerType.STICKER -> drawSticker(canvas, layer, geometry.shortSide, alpha, bitmapResolver)
         LayerType.OVERLAY -> drawOverlay(canvas, layer, geometry.shortSide, alpha, bitmapResolver)
+        LayerType.DRAWING -> drawStroke(canvas, layer, result.width.toFloat(), result.height.toFloat(), geometry.shortSide, alpha)
       }
       canvas.restore()
     }
@@ -75,7 +77,9 @@ object PhotoLayerRenderer {
     if (uri != null) {
       resolver(uri)?.let { bitmap ->
         val paint = Paint(Paint.ANTI_ALIAS_FLAG).apply { this.alpha = alpha }
-        canvas.drawBitmap(bitmap, null, RectF(-size / 2, -size / 2, size / 2, size / 2), paint)
+        val aspect = layer.overlayAspectRatio?.takeIf { it > 0 } ?: (bitmap.width.toFloat() / bitmap.height)
+        val (width, height) = OverlayGeometry.stickerSize(shortSide, aspect)
+        canvas.drawBitmap(bitmap, null, RectF(-width / 2, -height / 2, width / 2, height / 2), paint)
         return
       }
     }
@@ -105,4 +109,23 @@ object PhotoLayerRenderer {
     val paint = Paint(Paint.ANTI_ALIAS_FLAG).apply { this.alpha = alpha }
     canvas.drawBitmap(bitmap, null, RectF(-width / 2, -height / 2, width / 2, height / 2), paint)
   }
+
+  private fun drawStroke(canvas: Canvas, layer: PhotoLayer, width: Float, height: Float, shortSide: Float, alpha: Int) {
+    if (layer.drawPoints.size < 2) return
+    val paint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+      color = layer.drawColor
+      this.alpha = alpha
+      style = Paint.Style.STROKE
+      strokeWidth = layer.drawStrokeWidth * shortSide
+      strokeCap = Paint.Cap.ROUND
+      strokeJoin = Paint.Join.ROUND
+    }
+    val path = Path()
+    layer.drawPoints.forEachIndexed { index, (dx, dy) ->
+      val px = dx * width
+      val py = dy * height
+      if (index == 0) path.moveTo(px, py) else path.lineTo(px, py)
+    }
+    canvas.drawPath(path, paint)
+  }
 }

package/android/src/main/java/com/photovideoeditor/photo/render/PhotoTransformRenderer.kt

@@ -0,0 +1,33 @@
+package com.photovideoeditor.photo.render
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Matrix
+import android.graphics.Paint
+import kotlin.math.roundToInt
+
+/** The same upright, auto-filled straighten and normalized crop pipeline for preview and export. */
+object PhotoTransformRenderer {
+  fun transform(source: Bitmap, state: PhotoTransformState): Bitmap {
+    val oriented = if (state.rotationDegrees % 360 == 0) source else Bitmap.createBitmap(
+      source, 0, 0, source.width, source.height, Matrix().apply { postRotate(state.rotationDegrees.toFloat()) }, true)
+    if (state.straightenDegrees == 0f) return oriented
+    val output = Bitmap.createBitmap(oriented.width, oriented.height, Bitmap.Config.ARGB_8888)
+    val canvas = Canvas(output)
+    val fill = CropGeometry.fillScale(oriented.width.toFloat(), oriented.height.toFloat(), state.straightenDegrees)
+    canvas.translate(oriented.width / 2f, oriented.height / 2f)
+    canvas.rotate(state.straightenDegrees)
+    canvas.scale(fill, fill)
+    canvas.drawBitmap(oriented, -oriented.width / 2f, -oriented.height / 2f, Paint(Paint.ANTI_ALIAS_FLAG or Paint.FILTER_BITMAP_FLAG))
+    if (oriented !== source) oriented.recycle()
+    return output
+  }
+
+  fun crop(bitmap: Bitmap, state: PhotoTransformState): Bitmap {
+    val left = (state.cropLeft * bitmap.width).roundToInt().coerceIn(0, bitmap.width - 1)
+    val top = (state.cropTop * bitmap.height).roundToInt().coerceIn(0, bitmap.height - 1)
+    val right = (state.cropRight * bitmap.width).roundToInt().coerceIn(left + 1, bitmap.width)
+    val bottom = (state.cropBottom * bitmap.height).roundToInt().coerceIn(top + 1, bitmap.height)
+    return Bitmap.createBitmap(bitmap, left, top, right - left, bottom - top)
+  }
+}

package/android/src/main/java/com/photovideoeditor/photo/render/PhotoTransformState.kt

@@ -15,7 +15,12 @@ data class PhotoTransformState(
   val cropBottom: Float = 1f,
   val rotationDegrees: Int = 0,
   val straightenDegrees: Float = 0f,
-  val aspectRatio: Float? = null
+  val aspectRatio: Float? = null,
+  val aspectPreset: String = "Free",
+  // Viewport metadata only: zoom/pan are already encoded in normalized crop coordinates for export.
+  val zoom: Float = 1f,
+  val panX: Float = 0f,
+  val panY: Float = 0f
 ) {
   val isIdentity: Boolean
     get() = cropLeft == 0f && cropTop == 0f && cropRight == 1f && cropBottom == 1f &&