diff --git a/cropper/src/main/java/com/theartofdev/edmodo/cropper/BitmapCroppingWorkerTask.java b/cropper/src/main/java/com/theartofdev/edmodo/cropper/BitmapCroppingWorkerTask.java
index e5c7a7e2..702da115 100644
--- a/cropper/src/main/java/com/theartofdev/edmodo/cropper/BitmapCroppingWorkerTask.java
+++ b/cropper/src/main/java/com/theartofdev/edmodo/cropper/BitmapCroppingWorkerTask.java
@@ -91,6 +91,16 @@ final class BitmapCroppingWorkerTask extends AsyncTask<Void, Void, BitmapCroppin
      */
     private final int mReqHeight;
 
+    /**
+     * is the image flipped horizontally
+     */
+    private final boolean mFlipHorizontally;
+
+    /**
+     * is the image flipped vertically
+     */
+    private final boolean mFlipVertically;
+
     /**
      * The option to handle requested width/height
      */
@@ -114,7 +124,7 @@ final class BitmapCroppingWorkerTask extends AsyncTask<Void, Void, BitmapCroppin
 
     BitmapCroppingWorkerTask(CropImageView cropImageView, Bitmap bitmap, float[] cropPoints,
                              int degreesRotated, boolean fixAspectRatio, int aspectRatioX, int aspectRatioY,
-                             int reqWidth, int reqHeight, CropImageView.RequestSizeOptions options,
+                             int reqWidth, int reqHeight, boolean flipHorizontally, boolean flipVertically, CropImageView.RequestSizeOptions options,
                              Uri saveUri, Bitmap.CompressFormat saveCompressFormat, int saveCompressQuality) {
 
         mCropImageViewReference = new WeakReference<>(cropImageView);
@@ -128,6 +138,8 @@ final class BitmapCroppingWorkerTask extends AsyncTask<Void, Void, BitmapCroppin
         mAspectRatioY = aspectRatioY;
         mReqWidth = reqWidth;
         mReqHeight = reqHeight;
+        mFlipHorizontally = flipHorizontally;
+        mFlipVertically = flipVertically;
         mReqSizeOptions = options;
         mSaveUri = saveUri;
         mSaveCompressFormat = saveCompressFormat;
@@ -138,8 +150,8 @@ final class BitmapCroppingWorkerTask extends AsyncTask<Void, Void, BitmapCroppin
 
     BitmapCroppingWorkerTask(CropImageView cropImageView, Uri uri, float[] cropPoints,
                              int degreesRotated, int orgWidth, int orgHeight,
-                             boolean fixAspectRatio, int aspectRatioX, int aspectRatioY,
-                             int reqWidth, int reqHeight, CropImageView.RequestSizeOptions options,
+                             boolean fixAspectRatio, int aspectRatioX, int aspectRatioY, int reqWidth, int reqHeight,
+                             boolean flipHorizontally, boolean flipVertically, CropImageView.RequestSizeOptions options,
                              Uri saveUri, Bitmap.CompressFormat saveCompressFormat, int saveCompressQuality) {
 
         mCropImageViewReference = new WeakReference<>(cropImageView);
@@ -154,6 +166,8 @@ final class BitmapCroppingWorkerTask extends AsyncTask<Void, Void, BitmapCroppin
         mOrgHeight = orgHeight;
         mReqWidth = reqWidth;
         mReqHeight = reqHeight;
+        mFlipHorizontally = flipHorizontally;
+        mFlipVertically = flipVertically;
         mReqSizeOptions = options;
         mSaveUri = saveUri;
         mSaveCompressFormat = saveCompressFormat;
@@ -182,9 +196,10 @@ protected BitmapCroppingWorkerTask.Result doInBackground(Void... params) {
                 BitmapUtils.BitmapSampled bitmapSampled;
                 if (mUri != null) {
                     bitmapSampled = BitmapUtils.cropBitmap(mContext, mUri, mCropPoints, mDegreesRotated, mOrgWidth, mOrgHeight,
-                            mFixAspectRatio, mAspectRatioX, mAspectRatioY, mReqWidth, mReqHeight);
+                            mFixAspectRatio, mAspectRatioX, mAspectRatioY, mReqWidth, mReqHeight, mFlipHorizontally, mFlipVertically);
                 } else if (mBitmap != null) {
-                    bitmapSampled = BitmapUtils.cropBitmapObjectHandleOOM(mBitmap, mCropPoints, mDegreesRotated, mFixAspectRatio, mAspectRatioX, mAspectRatioY);
+                    bitmapSampled = BitmapUtils.cropBitmapObjectHandleOOM(mBitmap, mCropPoints, mDegreesRotated, mFixAspectRatio,
+                            mAspectRatioX, mAspectRatioY, mFlipHorizontally, mFlipVertically);
                 } else {
                     return new Result((Bitmap) null, 1);
                 }
diff --git a/cropper/src/main/java/com/theartofdev/edmodo/cropper/BitmapUtils.java b/cropper/src/main/java/com/theartofdev/edmodo/cropper/BitmapUtils.java
index 1f66ee83..df426acf 100644
--- a/cropper/src/main/java/com/theartofdev/edmodo/cropper/BitmapUtils.java
+++ b/cropper/src/main/java/com/theartofdev/edmodo/cropper/BitmapUtils.java
@@ -149,11 +149,13 @@ static BitmapSampled decodeSampledBitmap(Context context, Uri uri, int reqWidth,
      * If crop fails due to OOM we scale the cropping image by 0.5 every time it fails until it is small enough.
      */
     static BitmapSampled cropBitmapObjectHandleOOM(Bitmap bitmap, float[] points, int degreesRotated,
-                                                   boolean fixAspectRatio, int aspectRatioX, int aspectRatioY) {
+                                                   boolean fixAspectRatio, int aspectRatioX, int aspectRatioY,
+                                                   boolean flipHorizontally, boolean flipVertically) {
         int scale = 1;
         while (true) {
             try {
-                Bitmap cropBitmap = cropBitmapObjectWithScale(bitmap, points, degreesRotated, fixAspectRatio, aspectRatioX, aspectRatioY, 1 / (float) scale);
+                Bitmap cropBitmap = cropBitmapObjectWithScale(bitmap, points, degreesRotated, fixAspectRatio, aspectRatioX, aspectRatioY,
+                        1 / (float) scale, flipHorizontally, flipVertically);
                 return new BitmapSampled(cropBitmap, scale);
             } catch (OutOfMemoryError e) {
                 scale *= 2;
@@ -172,14 +174,26 @@ static BitmapSampled cropBitmapObjectHandleOOM(Bitmap bitmap, float[] points, in
      * @param scale how much to scale the cropped image part, use 0.5 to lower the image by half (OOM handling)
      */
     private static Bitmap cropBitmapObjectWithScale(Bitmap bitmap, float[] points, int degreesRotated,
-                                                    boolean fixAspectRatio, int aspectRatioX, int aspectRatioY, float scale) {
+                                                    boolean fixAspectRatio, int aspectRatioX, int aspectRatioY, float scale,
+                                                    boolean flipHorizontally, boolean flipVertically) {
 
         // get the rectangle in original image that contains the required cropped area (larger for non rectangular crop)
         Rect rect = getRectFromPoints(points, bitmap.getWidth(), bitmap.getHeight(), fixAspectRatio, aspectRatioX, aspectRatioY);
 
+        if (degreesRotated == 90 || degreesRotated == 270) {
+            if (flipHorizontally != flipVertically) {
+                boolean temp = flipHorizontally;
+                flipHorizontally = flipVertically;
+                flipVertically = temp;
+            }
+        }
+
         // crop and rotate the cropped image in one operation
+        float scaleX = flipHorizontally ? -scale : scale;
+        float scaleY = flipVertically ? -scale : scale;
+
         Matrix matrix = new Matrix();
-        matrix.setScale(scale, scale);
+        matrix.setScale(scaleX, scaleY);
         matrix.postRotate(degreesRotated, bitmap.getWidth() / 2, bitmap.getHeight() / 2);
         Bitmap result = Bitmap.createBitmap(bitmap, rect.left, rect.top, rect.width(), rect.height(), matrix, true);
 
@@ -204,7 +218,8 @@ private static Bitmap cropBitmapObjectWithScale(Bitmap bitmap, float[] points, i
      */
     static BitmapSampled cropBitmap(Context context, Uri loadedImageUri, float[] points,
                                     int degreesRotated, int orgWidth, int orgHeight, boolean fixAspectRatio,
-                                    int aspectRatioX, int aspectRatioY, int reqWidth, int reqHeight) {
+                                    int aspectRatioX, int aspectRatioY, int reqWidth, int reqHeight,
+                                    boolean flipHorizontally, boolean flipVertically) {
         int sampleMulti = 1;
         while (true) {
             try {
@@ -212,7 +227,7 @@ static BitmapSampled cropBitmap(Context context, Uri loadedImageUri, float[] poi
                 return cropBitmap(context, loadedImageUri, points,
                         degreesRotated, orgWidth, orgHeight, fixAspectRatio,
                         aspectRatioX, aspectRatioY, reqWidth, reqHeight,
-                        sampleMulti);
+                        flipHorizontally, flipVertically, sampleMulti);
             } catch (OutOfMemoryError e) {
                 // if OOM try to increase the sampling to lower the memory usage
                 sampleMulti *= 2;
@@ -366,9 +381,9 @@ static Bitmap resizeBitmap(Bitmap bitmap, int reqWidth, int reqHeight, CropImage
      * @param orgHeight used to get rectangle from points (handle edge cases to limit rectangle)
      * @param sampleMulti used to increase the sampling of the image to handle memory issues.
      */
-    private static BitmapSampled cropBitmap(Context context, Uri loadedImageUri, float[] points,
-                                            int degreesRotated, int orgWidth, int orgHeight, boolean fixAspectRatio,
-                                            int aspectRatioX, int aspectRatioY, int reqWidth, int reqHeight, int sampleMulti) {
+    private static BitmapSampled cropBitmap(Context context, Uri loadedImageUri, float[] points, int degreesRotated,
+                                            int orgWidth, int orgHeight, boolean fixAspectRatio, int aspectRatioX, int aspectRatioY,
+                                            int reqWidth, int reqHeight, boolean flipHorizontally, boolean flipVertically, int sampleMulti) {
 
         // get the rectangle in original image that contains the required cropped area (larger for non rectangular crop)
         Rect rect = getRectFromPoints(points, orgWidth, orgHeight, fixAspectRatio, aspectRatioX, aspectRatioY);
@@ -406,7 +421,8 @@ private static BitmapSampled cropBitmap(Context context, Uri loadedImageUri, flo
             return new BitmapSampled(result, sampleSize);
         } else {
             // failed to decode region, may be skia issue, try full decode and then crop
-            return cropBitmap(context, loadedImageUri, points, degreesRotated, fixAspectRatio, aspectRatioX, aspectRatioY, sampleMulti, rect, width, height);
+            return cropBitmap(context, loadedImageUri, points, degreesRotated, fixAspectRatio, aspectRatioX, aspectRatioY, sampleMulti,
+                    rect, width, height, flipHorizontally, flipVertically);
         }
     }
 
@@ -415,7 +431,7 @@ private static BitmapSampled cropBitmap(Context context, Uri loadedImageUri, flo
      */
     private static BitmapSampled cropBitmap(Context context, Uri loadedImageUri, float[] points,
                                             int degreesRotated, boolean fixAspectRatio, int aspectRatioX, int aspectRatioY,
-                                            int sampleMulti, Rect rect, int width, int height) {
+                                            int sampleMulti, Rect rect, int width, int height, boolean flipHorizontally, boolean flipVertically) {
         Bitmap result = null;
         int sampleSize;
         try {
@@ -432,7 +448,8 @@ private static BitmapSampled cropBitmap(Context context, Uri loadedImageUri, flo
                         points2[i] = points2[i] / options.inSampleSize;
                     }
 
-                    result = cropBitmapObjectWithScale(fullBitmap, points2, degreesRotated, fixAspectRatio, aspectRatioX, aspectRatioY, 1);
+                    result = cropBitmapObjectWithScale(fullBitmap, points2, degreesRotated, fixAspectRatio, aspectRatioX, aspectRatioY, 1,
+                            flipHorizontally, flipVertically);
                 } finally {
                     if (result != fullBitmap) {
                         fullBitmap.recycle();
diff --git a/cropper/src/main/java/com/theartofdev/edmodo/cropper/CropImageOptions.java b/cropper/src/main/java/com/theartofdev/edmodo/cropper/CropImageOptions.java
index 26cc1b80..041ded2b 100644
--- a/cropper/src/main/java/com/theartofdev/edmodo/cropper/CropImageOptions.java
+++ b/cropper/src/main/java/com/theartofdev/edmodo/cropper/CropImageOptions.java
@@ -263,6 +263,16 @@ public CropImageOptions[] newArray(int size) {
      */
     public int rotationDegrees;
 
+    /**
+     * whether the image should be flipped horizontally
+     */
+    public boolean flipHorizontally;
+
+    /**
+     * whether the image should be flipped vertically
+     */
+    public boolean flipVertically;
+
     /**
      * Init options with defaults.
      */
@@ -320,6 +330,8 @@ public CropImageOptions() {
         allowRotation = true;
         allowCounterRotation = false;
         rotationDegrees = 90;
+        flipHorizontally = false;
+        flipVertically = false;
     }
 
     /**
@@ -369,6 +381,8 @@ protected CropImageOptions(Parcel in) {
         allowRotation = in.readByte() != 0;
         allowCounterRotation = in.readByte() != 0;
         rotationDegrees = in.readInt();
+        flipHorizontally = in.readByte() != 0;
+        flipVertically = in.readByte() != 0;
     }
 
     @Override
@@ -416,6 +430,8 @@ public void writeToParcel(Parcel dest, int flags) {
         dest.writeByte((byte) (allowRotation ? 1 : 0));
         dest.writeByte((byte) (allowCounterRotation ? 1 : 0));
         dest.writeInt(rotationDegrees);
+        dest.writeByte((byte) (flipHorizontally ? 1 : 0));
+        dest.writeByte((byte) (flipVertically ? 1 : 0));
     }
 
     @Override
diff --git a/cropper/src/main/java/com/theartofdev/edmodo/cropper/CropImageView.java b/cropper/src/main/java/com/theartofdev/edmodo/cropper/CropImageView.java
index 4f2766b2..87fc8635 100644
--- a/cropper/src/main/java/com/theartofdev/edmodo/cropper/CropImageView.java
+++ b/cropper/src/main/java/com/theartofdev/edmodo/cropper/CropImageView.java
@@ -242,6 +242,8 @@ public CropImageView(Context context, AttributeSet attrs) {
                     options.minCropResultHeight = (int) ta.getFloat(R.styleable.CropImageView_cropMinCropResultHeightPX, options.minCropResultHeight);
                     options.maxCropResultWidth = (int) ta.getFloat(R.styleable.CropImageView_cropMaxCropResultWidthPX, options.maxCropResultWidth);
                     options.maxCropResultHeight = (int) ta.getFloat(R.styleable.CropImageView_cropMaxCropResultHeightPX, options.maxCropResultHeight);
+                    options.flipHorizontally = ta.getBoolean(R.styleable.CropImageView_cropFlipHorizontally, options.flipHorizontally);
+                    options.flipVertically = ta.getBoolean(R.styleable.CropImageView_cropFlipHorizontally, options.flipVertically);
 
                     // if aspect ratio is set then set fixed to true
                     if (ta.hasValue(R.styleable.CropImageView_cropAspectRatioX) &&
@@ -417,6 +419,34 @@ public void setFixedAspectRatio(boolean fixAspectRatio) {
         mCropOverlayView.setFixedAspectRatio(fixAspectRatio);
     }
 
+    /**
+     * whether the image should be flipped horizontally
+     */
+    public boolean isFlippedHorizontally() {
+        return mCropOverlayView.getIsFlippedHorizontally();
+    }
+
+    /**
+     * Sets whether the image should be flipped horizontally
+     */
+    public void setFlippedHorizontally(boolean flipHorizontally) {
+        mCropOverlayView.setFlipHorizontally(flipHorizontally);
+    }
+
+    /**
+     * whether the image should be flipped vertically
+     */
+    public boolean isFlippedVertically() {
+        return mCropOverlayView.getIsFlippedVertically();
+    }
+
+    /**
+     * Sets whether the image should be flipped vertically
+     */
+    public void setFlippedVertically(boolean flipVertically) {
+        mCropOverlayView.setFlipVertically(flipVertically);
+    }
+
     /**
      * Get the current guidelines option set.
      */
@@ -647,11 +677,12 @@ public Bitmap getCroppedImage(int reqWidth, int reqHeight, RequestSizeOptions op
                         BitmapUtils.cropBitmap(getContext(), mLoadedImageUri, getCropPoints(),
                                 mDegreesRotated, orgWidth, orgHeight,
                                 mCropOverlayView.isFixAspectRatio(), mCropOverlayView.getAspectRatioX(), mCropOverlayView.getAspectRatioY(),
-                                reqWidth, reqHeight);
+                                reqWidth, reqHeight, mCropOverlayView.getIsFlippedHorizontally(), mCropOverlayView.getIsFlippedVertically());
                 croppedBitmap = bitmapSampled.bitmap;
             } else {
                 croppedBitmap = BitmapUtils.cropBitmapObjectHandleOOM(mBitmap, getCropPoints(), mDegreesRotated,
-                        mCropOverlayView.isFixAspectRatio(), mCropOverlayView.getAspectRatioX(), mCropOverlayView.getAspectRatioY()).bitmap;
+                        mCropOverlayView.isFixAspectRatio(), mCropOverlayView.getAspectRatioX(), mCropOverlayView.getAspectRatioY(),
+                        mCropOverlayView.getIsFlippedHorizontally(), mCropOverlayView.getIsFlippedVertically()).bitmap;
             }
 
             croppedBitmap = BitmapUtils.resizeBitmap(croppedBitmap, reqWidth, reqHeight, options);
@@ -936,6 +967,22 @@ public void rotateImage(int degrees) {
         }
     }
 
+    /**
+     * Flips the image horizontally.
+     */
+    public void flipImageHorizontally() {
+        mCropOverlayView.setFlipHorizontally(!mCropOverlayView.getIsFlippedHorizontally());
+        applyImageMatrix(getWidth(), getHeight(), true, false);
+    }
+
+    /**
+     * Flips the image vertically.
+     */
+    public void flipImageVertically() {
+        mCropOverlayView.setFlipVertically(!mCropOverlayView.getIsFlippedVertically());
+        applyImageMatrix(getWidth(), getHeight(), true, false);
+    }
+
     //region: Private methods
 
     /**
@@ -1097,12 +1144,12 @@ public void startCropWorkerTask(int reqWidth, int reqHeight, RequestSizeOptions
                 mBitmapCroppingWorkerTask = new WeakReference<>(new BitmapCroppingWorkerTask(this, mLoadedImageUri, getCropPoints(),
                         mDegreesRotated, orgWidth, orgHeight,
                         mCropOverlayView.isFixAspectRatio(), mCropOverlayView.getAspectRatioX(), mCropOverlayView.getAspectRatioY(),
-                        reqWidth, reqHeight, options,
+                        reqWidth, reqHeight, mCropOverlayView.getIsFlippedHorizontally(), mCropOverlayView.getIsFlippedVertically(), options,
                         saveUri, saveCompressFormat, saveCompressQuality));
             } else {
                 mBitmapCroppingWorkerTask = new WeakReference<>(new BitmapCroppingWorkerTask(this, mBitmap, getCropPoints(), mDegreesRotated,
                         mCropOverlayView.isFixAspectRatio(), mCropOverlayView.getAspectRatioX(), mCropOverlayView.getAspectRatioY(),
-                        reqWidth, reqHeight, options,
+                        reqWidth, reqHeight, mCropOverlayView.getIsFlippedHorizontally(), mCropOverlayView.getIsFlippedVertically(), options,
                         saveUri, saveCompressFormat, saveCompressQuality));
             }
             mBitmapCroppingWorkerTask.get().execute();
@@ -1143,6 +1190,8 @@ public Parcelable onSaveInstanceState() {
         bundle.putString("CROP_SHAPE", mCropOverlayView.getCropShape().name());
         bundle.putBoolean("CROP_AUTO_ZOOM_ENABLED", mAutoZoomEnabled);
         bundle.putInt("CROP_MAX_ZOOM", mMaxZoom);
+        bundle.putBoolean("CROP_FLIP_HORIZONTALLY", mCropOverlayView.getIsFlippedHorizontally());
+        bundle.putBoolean("CROP_FLIP_VERTICALLY", mCropOverlayView.getIsFlippedVertically());
 
         return bundle;
     }
@@ -1197,6 +1246,9 @@ public void onRestoreInstanceState(Parcelable state) {
 
                 mAutoZoomEnabled = bundle.getBoolean("CROP_AUTO_ZOOM_ENABLED");
                 mMaxZoom = bundle.getInt("CROP_MAX_ZOOM");
+
+                mCropOverlayView.setFlipHorizontally(bundle.getBoolean("CROP_FLIP_HORIZONTALLY"));
+                mCropOverlayView.setFlipVertically(bundle.getBoolean("CROP_FLIP_VERTICALLY"));
             }
 
             super.onRestoreInstanceState(bundle.getParcelable("instanceState"));
@@ -1390,7 +1442,9 @@ private void applyImageMatrix(float width, float height, boolean center, boolean
             }
 
             // scale by the current zoom level
-            mImageMatrix.postScale(mZoom, mZoom, BitmapUtils.getRectCenterX(mImagePoints), BitmapUtils.getRectCenterY(mImagePoints));
+            float scaleX = mCropOverlayView.getIsFlippedHorizontally() ? -mZoom : mZoom;
+            float scaleY = mCropOverlayView.getIsFlippedVertically() ? -mZoom : mZoom;
+            mImageMatrix.postScale(scaleX, scaleY, BitmapUtils.getRectCenterX(mImagePoints), BitmapUtils.getRectCenterY(mImagePoints));
             mapImagePointsByImageMatrix();
 
             mImageMatrix.mapRect(cropRect);
@@ -1398,20 +1452,21 @@ private void applyImageMatrix(float width, float height, boolean center, boolean
             if (center) {
                 // set the zoomed area to be as to the center of cropping window as possible
                 mZoomOffsetX = width > BitmapUtils.getRectWidth(mImagePoints) ? 0
-                        : Math.max(Math.min(width / 2 - cropRect.centerX(), -BitmapUtils.getRectLeft(mImagePoints)), getWidth() - BitmapUtils.getRectRight(mImagePoints)) / mZoom;
+                        : Math.max(Math.min(width / 2 - cropRect.centerX(), -BitmapUtils.getRectLeft(mImagePoints)), getWidth() - BitmapUtils.getRectRight(mImagePoints)) / scaleX;
                 mZoomOffsetY = height > BitmapUtils.getRectHeight(mImagePoints) ? 0
-                        : Math.max(Math.min(height / 2 - cropRect.centerY(), -BitmapUtils.getRectTop(mImagePoints)), getHeight() - BitmapUtils.getRectBottom(mImagePoints)) / mZoom;
+                        : Math.max(Math.min(height / 2 - cropRect.centerY(), -BitmapUtils.getRectTop(mImagePoints)), getHeight() - BitmapUtils.getRectBottom(mImagePoints)) / scaleY;
             } else {
                 // adjust the zoomed area so the crop window rectangle will be inside the area in case it was moved outside
-                mZoomOffsetX = Math.min(Math.max(mZoomOffsetX * mZoom, -cropRect.left), -cropRect.right + width) / mZoom;
-                mZoomOffsetY = Math.min(Math.max(mZoomOffsetY * mZoom, -cropRect.top), -cropRect.bottom + height) / mZoom;
+                mZoomOffsetX = Math.min(Math.max(mZoomOffsetX * scaleX, -cropRect.left), -cropRect.right + width) / scaleX;
+                mZoomOffsetY = Math.min(Math.max(mZoomOffsetY * scaleY, -cropRect.top), -cropRect.bottom + height) / scaleY;
             }
 
             // apply to zoom offset translate and update the crop rectangle to offset correctly
-            mImageMatrix.postTranslate(mZoomOffsetX * mZoom, mZoomOffsetY * mZoom);
-            cropRect.offset(mZoomOffsetX * mZoom, mZoomOffsetY * mZoom);
+            mImageMatrix.postTranslate(mZoomOffsetX * scaleX, mZoomOffsetY * scaleY);
+            cropRect.offset(mZoomOffsetX * scaleX, mZoomOffsetY * scaleY);
             mCropOverlayView.setCropWindowRect(cropRect);
             mapImagePointsByImageMatrix();
+            mCropOverlayView.invalidate();
 
             // set matrix to apply
             if (animate) {
diff --git a/cropper/src/main/java/com/theartofdev/edmodo/cropper/CropOverlayView.java b/cropper/src/main/java/com/theartofdev/edmodo/cropper/CropOverlayView.java
index 0d2ac520..eb3c9d8b 100644
--- a/cropper/src/main/java/com/theartofdev/edmodo/cropper/CropOverlayView.java
+++ b/cropper/src/main/java/com/theartofdev/edmodo/cropper/CropOverlayView.java
@@ -158,6 +158,16 @@ public class CropOverlayView extends View {
      */
     private float mTargetAspectRatio = ((float) mAspectRatioX) / mAspectRatioY;
 
+    /**
+     * Flag indicating if the image should be flipped horizontally
+     */
+    private boolean mFlipHorizontally;
+
+    /**
+     * Flag indicating if the image should be flipped vertically
+     */
+    private boolean mFlipVertically;
+
     /**
      * Instance variables for customizable attributes
      */
@@ -379,6 +389,34 @@ public void setAspectRatioY(int aspectRatioY) {
         }
     }
 
+    /**
+     * whether the image is flipped horizontally
+     */
+    public boolean getIsFlippedHorizontally() {
+        return mFlipHorizontally;
+    }
+
+    /**
+     * Sets whether the image should be flipped horizontally
+     */
+    public void setFlipHorizontally(boolean flipHorizontally) {
+        mFlipHorizontally = flipHorizontally;
+    }
+
+    /**
+     * whether the image is flipped vertically
+     */
+    public boolean getIsFlippedVertically() {
+        return mFlipVertically;
+    }
+
+    /**
+     * Sets whether the image should be flipped vertically
+     */
+    public void setFlipVertically(boolean flipVertically) {
+        mFlipVertically = flipVertically;
+    }
+
     /**
      * An edge of the crop window will snap to the corresponding edge of a
      * specified bounding box when the crop window edge is less than or equal to
@@ -476,6 +514,8 @@ public void setInitialAttributeValues(CropImageOptions options) {
 
         setAspectRatioY(options.aspectRatioY);
 
+        setFlipHorizontally(options.flipHorizontally);
+
         setMultiTouchEnabled(options.multiTouchEnabled);
 
         mTouchRadius = options.touchRadius;
diff --git a/cropper/src/main/res/drawable-hdpi/crop_image_menu_flip.png b/cropper/src/main/res/drawable-hdpi/crop_image_menu_flip.png
new file mode 100644
index 00000000..133395df
Binary files /dev/null and b/cropper/src/main/res/drawable-hdpi/crop_image_menu_flip.png differ
diff --git a/cropper/src/main/res/drawable-xhdpi/crop_image_menu_flip.png b/cropper/src/main/res/drawable-xhdpi/crop_image_menu_flip.png
new file mode 100644
index 00000000..79910ffe
Binary files /dev/null and b/cropper/src/main/res/drawable-xhdpi/crop_image_menu_flip.png differ
diff --git a/cropper/src/main/res/drawable-xxhdpi/crop_image_menu_flip.png b/cropper/src/main/res/drawable-xxhdpi/crop_image_menu_flip.png
new file mode 100644
index 00000000..3629e38d
Binary files /dev/null and b/cropper/src/main/res/drawable-xxhdpi/crop_image_menu_flip.png differ
diff --git a/cropper/src/main/res/drawable-xxxhdpi/crop_image_menu_flip.png b/cropper/src/main/res/drawable-xxxhdpi/crop_image_menu_flip.png
new file mode 100644
index 00000000..4200cb86
Binary files /dev/null and b/cropper/src/main/res/drawable-xxxhdpi/crop_image_menu_flip.png differ
diff --git a/cropper/src/main/res/values/attrs.xml b/cropper/src/main/res/values/attrs.xml
index d1622b03..5719ac98 100644
--- a/cropper/src/main/res/values/attrs.xml
+++ b/cropper/src/main/res/values/attrs.xml
@@ -42,6 +42,8 @@
         <attr name="cropMinCropResultHeightPX" format="float"/>
         <attr name="cropMaxCropResultWidthPX" format="float"/>
         <attr name="cropMaxCropResultHeightPX" format="float"/>
+        <attr name="cropFlipHorizontally" format="boolean"/>
+        <attr name="cropFlipVertically" format="boolean"/>
     </declare-styleable>
 
 </resources>
\ No newline at end of file
diff --git a/sample/src/main/java/com/theartofdev/edmodo/cropper/sample/CropImageViewOptions.java b/sample/src/main/java/com/theartofdev/edmodo/cropper/sample/CropImageViewOptions.java
index ae27807a..9f0400af 100644
--- a/sample/src/main/java/com/theartofdev/edmodo/cropper/sample/CropImageViewOptions.java
+++ b/sample/src/main/java/com/theartofdev/edmodo/cropper/sample/CropImageViewOptions.java
@@ -40,4 +40,8 @@ final class CropImageViewOptions {
     public boolean showCropOverlay;
 
     public boolean showProgressBar;
+
+    public boolean flipHorizontally;
+
+    public boolean flipVertically;
 }
diff --git a/sample/src/main/java/com/theartofdev/edmodo/cropper/sample/MainFragment.java b/sample/src/main/java/com/theartofdev/edmodo/cropper/sample/MainFragment.java
index 731fe2b1..41434291 100644
--- a/sample/src/main/java/com/theartofdev/edmodo/cropper/sample/MainFragment.java
+++ b/sample/src/main/java/com/theartofdev/edmodo/cropper/sample/MainFragment.java
@@ -76,6 +76,8 @@ public void setCropImageViewOptions(CropImageViewOptions options) {
         mCropImageView.setShowProgressBar(options.showProgressBar);
         mCropImageView.setAutoZoomEnabled(options.autoZoomEnabled);
         mCropImageView.setMaxZoom(options.maxZoomLevel);
+        mCropImageView.setFlippedHorizontally(options.flipHorizontally);
+        mCropImageView.setFlippedVertically(options.flipVertically);
     }
 
     /**
@@ -103,6 +105,8 @@ public void updateCurrentCropViewOptions() {
         options.showProgressBar = mCropImageView.isShowProgressBar();
         options.autoZoomEnabled = mCropImageView.isAutoZoomEnabled();
         options.maxZoomLevel = mCropImageView.getMaxZoom();
+        options.flipHorizontally = mCropImageView.isFlippedHorizontally();
+        options.flipVertically = mCropImageView.isFlippedVertically();
         ((MainActivity) getActivity()).setCurrentOptions(options);
     }
 
@@ -161,6 +165,12 @@ public boolean onOptionsItemSelected(MenuItem item) {
         } else if (item.getItemId() == R.id.main_action_rotate) {
             mCropImageView.rotateImage(90);
             return true;
+        } else if (item.getItemId() == R.id.main_action_flip_horizontally) {
+            mCropImageView.flipImageHorizontally();
+            return true;
+        } else if (item.getItemId() == R.id.main_action_flip_vertically) {
+            mCropImageView.flipImageVertically();
+            return true;
         }
         return super.onOptionsItemSelected(item);
     }
diff --git a/sample/src/main/res/menu/main.xml b/sample/src/main/res/menu/main.xml
index 7698c09d..35e28a81 100644
--- a/sample/src/main/res/menu/main.xml
+++ b/sample/src/main/res/menu/main.xml
@@ -1,11 +1,25 @@
 <menu xmlns:android="http://schemas.android.com/apk/res/android"
-      xmlns:app="http://schemas.android.com/apk/res-auto"
-      xmlns:tools="http://schemas.android.com/tools">
+      xmlns:app="http://schemas.android.com/apk/res-auto">
     <item
         android:id="@+id/main_action_rotate"
         android:icon="@android:drawable/ic_menu_rotate"
         android:title="@string/main_action_rotate"
         app:showAsAction="ifRoom"/>
+    <item
+        android:id="@+id/main_action_flip"
+        android:icon="@drawable/crop_image_menu_flip"
+        android:title="@string/main_action_flip"
+        app:showAsAction="ifRoom">
+        <menu>
+            <item
+                android:id="@+id/main_action_flip_horizontally"
+                android:title="@string/main_action_flip_horizontally"/>
+            <item
+                android:id="@+id/main_action_flip_vertically"
+                android:title="@string/main_action_flip_vertically"/>
+        </menu>
+    </item>
+
     <item
         android:id="@+id/main_action_crop"
         android:title="@string/main_action_crop"
diff --git a/sample/src/main/res/values/strings.xml b/sample/src/main/res/values/strings.xml
index 03c33a95..f52d74a0 100644
--- a/sample/src/main/res/values/strings.xml
+++ b/sample/src/main/res/values/strings.xml
@@ -11,6 +11,9 @@
 
     <string name="main_action_crop">CROP</string>
     <string name="main_action_rotate">Rotate 90 degrees clockwise</string>
+    <string name="main_action_flip">Flip</string>
+    <string name="main_action_flip_horizontally">Flip horizontally</string>
+    <string name="main_action_flip_vertically">Flip vertically</string>
     <string name="drawer_option_title">Crop View Presets</string>
     <string name="drawer_option_oval">Circular</string>
     <string name="drawer_option_rect">Rectangular</string>