diff --git a/ClosedXML/Excel/Drawings/IXLMarker.cs b/ClosedXML/Excel/Drawings/IXLMarker.cs
index 3f2bb92..d5c2ef4 100644
--- a/ClosedXML/Excel/Drawings/IXLMarker.cs
+++ b/ClosedXML/Excel/Drawings/IXLMarker.cs
@@ -1,15 +1,10 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Drawing;
 
 namespace ClosedXML.Excel.Drawings
 {
     internal interface IXLMarker
     {
-        Int32 ColumnId { get; set; }
-        Int32 RowId { get; set; }
-        Double ColumnOffset { get; set; }
-        Double RowOffset { get; set; }
+        IXLAddress Address { get; set; }
+        Point Offset { get; set; }
     }
 }
diff --git a/ClosedXML/Excel/Drawings/IXLPicture.cs b/ClosedXML/Excel/Drawings/IXLPicture.cs
index a4e0c48..d059776 100644
--- a/ClosedXML/Excel/Drawings/IXLPicture.cs
+++ b/ClosedXML/Excel/Drawings/IXLPicture.cs
@@ -1,11 +1,12 @@
 using System;
+using System.Drawing;
 using System.IO;
 
 namespace ClosedXML.Excel.Drawings
 {
     public interface IXLPicture : IDisposable
     {
-        IXLCell BottomRightCell { get; }
+        IXLAddress BottomRightCellAddress { get; }
 
         /// <summary>
         /// Type of image. The supported formats are defined by OpenXML's ImagePartType.
@@ -13,29 +14,42 @@
         /// </summary>
         XLPictureFormat Format { get; }
 
-        long Height { get; set; }
+        Int32 Height { get; set; }
         MemoryStream ImageStream { get; }
-        long Left { get; set; }
+        Int32 Left { get; set; }
         String Name { get; set; }
-        long OriginalHeight { get; }
-        long OriginalWidth { get; }
+        Int32 OriginalHeight { get; }
+        Int32 OriginalWidth { get; }
         XLPicturePlacement Placement { get; set; }
-        long Top { get; set; }
-        IXLCell TopLeftCell { get; }
-        long Width { get; set; }
+        Int32 Top { get; set; }
+        IXLAddress TopLeftCellAddress { get; }
+        Int32 Width { get; set; }
+        IXLWorksheet Worksheet { get; }
 
-        IXLPicture AtPosition(long left, long top);
+        Point GetOffset(XLMarkerPosition position);
 
-        IXLPicture AtPosition(IXLCell cell);
+        IXLPicture MoveTo(Int32 left, Int32 top);
 
-        IXLPicture AtPosition(IXLCell fromCell, IXLCell toCell);
+        IXLPicture MoveTo(IXLAddress cell);
 
-        void ScaleHeight(Double factor, Boolean relativeToOriginal = false);
+        IXLPicture MoveTo(IXLAddress cell, Int32 xOffset, Int32 yOffset);
 
-        void ScaleWidth(Double factor, Boolean relativeToOriginal = false);
+        IXLPicture MoveTo(IXLAddress cell, Point offset);
+
+        IXLPicture MoveTo(IXLAddress fromCell, IXLAddress toCell);
+
+        IXLPicture MoveTo(IXLAddress fromCell, Int32 fromCellXOffset, Int32 fromCellYOffset, IXLAddress toCell, Int32 toCellXOffset, Int32 toCellYOffset);
+
+        IXLPicture MoveTo(IXLAddress fromCell, Point fromOffset, IXLAddress toCell, Point toOffset);
+
+        IXLPicture Scale(Double factor, Boolean relativeToOriginal = false);
+
+        IXLPicture ScaleHeight(Double factor, Boolean relativeToOriginal = false);
+
+        IXLPicture ScaleWidth(Double factor, Boolean relativeToOriginal = false);
 
         IXLPicture WithPlacement(XLPicturePlacement value);
 
-        IXLPicture WithSize(long width, long height);
+        IXLPicture WithSize(Int32 width, Int32 height);
     }
 }
diff --git a/ClosedXML/Excel/Drawings/PictureEnums.cs b/ClosedXML/Excel/Drawings/PictureEnums.cs
index 4cd1fcf..3d76e73 100644
--- a/ClosedXML/Excel/Drawings/PictureEnums.cs
+++ b/ClosedXML/Excel/Drawings/PictureEnums.cs
@@ -1,11 +1,11 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
 namespace ClosedXML.Excel.Drawings
 {
+    public enum XLMarkerPosition
+    {
+        TopLeft,
+        BottomRight
+    }
+
     public enum XLPictureFormat
     {
         Bmp = 0,
diff --git a/ClosedXML/Excel/Drawings/XLMarker.cs b/ClosedXML/Excel/Drawings/XLMarker.cs
index 4934cad..f48bf5c 100644
--- a/ClosedXML/Excel/Drawings/XLMarker.cs
+++ b/ClosedXML/Excel/Drawings/XLMarker.cs
@@ -1,48 +1,23 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Diagnostics;
+using System.Drawing;
 
 namespace ClosedXML.Excel.Drawings
 {
+    [DebuggerDisplay("{Address} {Offset}")]
     internal class XLMarker : IXLMarker
     {
-        private Int32 colId;
-        private Int32 rowId;
+        internal XLMarker(IXLAddress address)
+            : this(address, new Point(0, 0))
+        { }
 
-        public Int32 ColumnId
+        internal XLMarker(IXLAddress address, Point offset)
         {
-            set
-            {
-                if (value < 1 || value > XLHelper.MaxColumnNumber)
-                    throw new ArgumentOutOfRangeException(String.Format("Column number must be between 1 and {0}",
-                                                                 XLHelper.MaxColumnNumber));
-                this.colId = value;
-            }
-            get
-            {
-                return this.colId;
-            }
+            this.Address = address;
+            this.Offset = offset;
         }
 
-        public Int32 RowId
-        {
-            set
-            {
-                if (value < 1 || value > XLHelper.MaxRowNumber)
-                    throw new ArgumentOutOfRangeException(String.Format("Row number must be between 1 and {0}",
-                                                                 XLHelper.MaxRowNumber));
-                this.rowId = value;
-            }
-            get
-            {
-                return this.rowId;
-            }
-        }
+        public IXLAddress Address { get; set; }
 
-        public Double ColumnOffset { get; set; }
-
-        public Double RowOffset { get; set; }
-
+        public Point Offset { get; set; }
     }
 }
diff --git a/ClosedXML/Excel/Drawings/XLPicture.cs b/ClosedXML/Excel/Drawings/XLPicture.cs
index 6cf81fc..d591f8f 100644
--- a/ClosedXML/Excel/Drawings/XLPicture.cs
+++ b/ClosedXML/Excel/Drawings/XLPicture.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Drawing;
 using System.Drawing.Imaging;
 using System.IO;
@@ -8,16 +9,13 @@
 
 namespace ClosedXML.Excel.Drawings
 {
+    [DebuggerDisplay("{Name}")]
     internal class XLPicture : IXLPicture
     {
         private readonly IXLWorksheet _worksheet;
 
-        private XLPicture(IXLWorksheet worksheet)
-        {
-            if (worksheet == null) throw new ArgumentNullException(nameof(worksheet));
-            this._worksheet = worksheet;
-            this.Placement = XLPicturePlacement.MoveAndSize;
-        }
+        private Int32 height;
+        private Int32 width;
 
         internal XLPicture(IXLWorksheet worksheet, Stream stream, XLPictureFormat format)
             : this(worksheet)
@@ -27,6 +25,7 @@
 
             this.ImageStream = new MemoryStream();
             {
+                stream.Position = 0;
                 stream.CopyTo(ImageStream);
                 ImageStream.Seek(0, SeekOrigin.Begin);
 
@@ -60,43 +59,38 @@
             this.Format = Enum.Parse(typeof(XLPictureFormat), formats.Single().Name, true).CastTo<XLPictureFormat>();
         }
 
-        public IXLCell BottomRightCell
+        private XLPicture(IXLWorksheet worksheet)
+        {
+            if (worksheet == null) throw new ArgumentNullException(nameof(worksheet));
+            this._worksheet = worksheet;
+            this.Placement = XLPicturePlacement.MoveAndSize;
+            this.Markers = new Dictionary<XLMarkerPosition, IXLMarker>()
+            {
+                [XLMarkerPosition.TopLeft] = null,
+                [XLMarkerPosition.BottomRight] = null
+            };
+        }
+
+        public IXLAddress BottomRightCellAddress
         {
             get
             {
-                if (this.Markers.Count > 1)
-                {
-                    var marker = this.Markers.Skip(1).First();
-                    return _worksheet.Cell(marker.RowId, marker.ColumnId);
-                }
-                else
-                    return null;
+                return Markers[XLMarkerPosition.BottomRight].Address;
             }
 
             private set
             {
-                while (this.Markers.Count > 1)
-                {
-                    this.Markers.RemoveAt(this.Markers.Count - 1);
-                }
-
-                this.Markers.Add(new XLMarker()
-                {
-                    ColumnId = value.WorksheetColumn().ColumnNumber(),
-                    RowId = value.WorksheetRow().RowNumber()
-                });
+                if (!value.Worksheet.Equals(this._worksheet))
+                    throw new ArgumentOutOfRangeException(nameof(value.Worksheet));
+                this.Markers[XLMarkerPosition.BottomRight] = new XLMarker(value);
             }
         }
 
         public XLPictureFormat Format { get; private set; }
-        private long height;
 
-        public long Height
+        public Int32 Height
         {
-            get
-            {
-                return height;
-            }
+            get { return height; }
             set
             {
                 if (this.Placement == XLPicturePlacement.MoveAndSize)
@@ -107,73 +101,54 @@
 
         public MemoryStream ImageStream { get; private set; }
 
-        public long left;
-
-        public long Left
+        public Int32 Left
         {
-            get { return left; }
+            get { return Markers[XLMarkerPosition.TopLeft]?.Offset.X ?? 0; }
             set
             {
                 if (this.Placement != XLPicturePlacement.FreeFloating)
                     throw new ArgumentException("To set the left-hand offset, the placement should be FreeFloating");
-                left = value;
+
+                Markers[XLMarkerPosition.TopLeft] = new XLMarker(_worksheet.Cell(1, 1).Address, new Point(value, this.Top));
             }
         }
 
-        public IList<IXLMarker> Markers { get; private set; } = new List<IXLMarker>();
         public String Name { get; set; }
-        public long OriginalHeight { get; private set; }
-
-        public long OriginalWidth { get; private set; }
-
+        public Int32 OriginalHeight { get; private set; }
+        public Int32 OriginalWidth { get; private set; }
         public XLPicturePlacement Placement { get; set; }
-        private long top;
 
-        public long Top
+        public Int32 Top
         {
-            get { return top; }
+            get { return Markers[XLMarkerPosition.TopLeft]?.Offset.Y ?? 0; }
             set
             {
                 if (this.Placement != XLPicturePlacement.FreeFloating)
                     throw new ArgumentException("To set the top offset, the placement should be FreeFloating");
-                top = value;
+
+                Markers[XLMarkerPosition.TopLeft] = new XLMarker(_worksheet.Cell(1, 1).Address, new Point(this.Left, value));
             }
         }
 
-        public IXLCell TopLeftCell
+        public IXLAddress TopLeftCellAddress
         {
             get
             {
-                if (this.Markers.Any())
-                {
-                    var marker = this.Markers.First();
-                    return _worksheet.Cell(marker.RowId, marker.ColumnId);
-                }
-                else
-                    return null;
+                return Markers[XLMarkerPosition.TopLeft].Address;
             }
 
             private set
             {
-                if (this.Markers.Any())
-                    this.Markers.RemoveAt(0);
+                if (!value.Worksheet.Equals(this._worksheet))
+                    throw new ArgumentOutOfRangeException(nameof(value.Worksheet));
 
-                this.Markers.Insert(0, new XLMarker()
-                {
-                    ColumnId = value.WorksheetColumn().ColumnNumber(),
-                    RowId = value.WorksheetRow().RowNumber()
-                });
+                this.Markers[XLMarkerPosition.TopLeft] = new XLMarker(value);
             }
         }
 
-        private long width;
-
-        public long Width
+        public Int32 Width
         {
-            get
-            {
-                return width;
-            }
+            get { return width; }
             set
             {
                 if (this.Placement == XLPicturePlacement.MoveAndSize)
@@ -182,7 +157,24 @@
             }
         }
 
-        public IXLPicture AtPosition(long left, long top)
+        public IXLWorksheet Worksheet
+        {
+            get { return _worksheet; }
+        }
+
+        internal IDictionary<XLMarkerPosition, IXLMarker> Markers { get; private set; }
+
+        public void Dispose()
+        {
+            this.ImageStream.Dispose();
+        }
+
+        public Point GetOffset(XLMarkerPosition position)
+        {
+            return Markers[position].Offset;
+        }
+
+        public IXLPicture MoveTo(Int32 left, Int32 top)
         {
             this.Placement = XLPicturePlacement.FreeFloating;
             this.Left = left;
@@ -190,39 +182,65 @@
             return this;
         }
 
-        public IXLPicture AtPosition(IXLCell cell)
+        public IXLPicture MoveTo(IXLAddress cell)
+        {
+            return MoveTo(cell, 0, 0);
+        }
+
+        public IXLPicture MoveTo(IXLAddress cell, Int32 xOffset, Int32 yOffset)
+        {
+            return MoveTo(cell, new Point(xOffset, yOffset));
+        }
+
+        public IXLPicture MoveTo(IXLAddress cell, Point offset)
         {
             if (cell == null) throw new ArgumentNullException(nameof(cell));
             this.Placement = XLPicturePlacement.Move;
-            this.TopLeftCell = cell;
+            this.TopLeftCellAddress = cell;
+            this.Markers[XLMarkerPosition.TopLeft].Offset = offset;
             return this;
         }
 
-        public IXLPicture AtPosition(IXLCell fromCell, IXLCell toCell)
+        public IXLPicture MoveTo(IXLAddress fromCell, IXLAddress toCell)
+        {
+            return MoveTo(fromCell, 0, 0, toCell, 0, 0);
+        }
+
+        public IXLPicture MoveTo(IXLAddress fromCell, Int32 fromCellXOffset, Int32 fromCellYOffset, IXLAddress toCell, Int32 toCellXOffset, Int32 toCellYOffset)
+        {
+            return MoveTo(fromCell, new Point(fromCellXOffset, fromCellYOffset), toCell, new Point(toCellXOffset, toCellYOffset));
+        }
+
+        public IXLPicture MoveTo(IXLAddress fromCell, Point fromOffset, IXLAddress toCell, Point toOffset)
         {
             if (fromCell == null) throw new ArgumentNullException(nameof(fromCell));
+            if (toCell == null) throw new ArgumentNullException(nameof(toCell));
             this.Placement = XLPicturePlacement.MoveAndSize;
-            this.TopLeftCell = fromCell;
 
-            if (toCell != null)
-                this.BottomRightCell = toCell;
+            this.TopLeftCellAddress = fromCell;
+            this.Markers[XLMarkerPosition.TopLeft].Offset = fromOffset;
+
+            this.BottomRightCellAddress = toCell;
+            this.Markers[XLMarkerPosition.BottomRight].Offset = toOffset;
 
             return this;
         }
 
-        public void Dispose()
+        public IXLPicture Scale(Double factor, Boolean relativeToOriginal = false)
         {
-            this.ImageStream.Dispose();
+            return this.ScaleHeight(factor, relativeToOriginal).ScaleWidth(factor, relativeToOriginal);
         }
 
-        public void ScaleHeight(Double factor, Boolean relativeToOriginal = false)
+        public IXLPicture ScaleHeight(Double factor, Boolean relativeToOriginal = false)
         {
-            this.Height = Convert.ToInt64((relativeToOriginal ? this.OriginalHeight : this.Height) * factor);
+            this.Height = Convert.ToInt32((relativeToOriginal ? this.OriginalHeight : this.Height) * factor);
+            return this;
         }
 
-        public void ScaleWidth(Double factor, Boolean relativeToOriginal = false)
+        public IXLPicture ScaleWidth(Double factor, Boolean relativeToOriginal = false)
         {
-            this.Width = Convert.ToInt64((relativeToOriginal ? this.OriginalWidth : this.Width) * factor);
+            this.Width = Convert.ToInt32((relativeToOriginal ? this.OriginalWidth : this.Width) * factor);
+            return this;
         }
 
         public IXLPicture WithPlacement(XLPicturePlacement value)
@@ -231,7 +249,7 @@
             return this;
         }
 
-        public IXLPicture WithSize(long width, long height)
+        public IXLPicture WithSize(Int32 width, Int32 height)
         {
             this.Width = width;
             this.Height = height;
diff --git a/ClosedXML/Excel/XLWorkbook_Save.cs b/ClosedXML/Excel/XLWorkbook_Save.cs
index e74db1d..457ecbc 100644
--- a/ClosedXML/Excel/XLWorkbook_Save.cs
+++ b/ClosedXML/Excel/XLWorkbook_Save.cs
@@ -2590,22 +2590,22 @@
                     break;
 
                 case Drawings.XLPicturePlacement.MoveAndSize:
-                    var moveAndSizeFromMarker = pic.Markers.First();
+                    var moveAndSizeFromMarker = pic.Markers[Drawings.XLMarkerPosition.TopLeft];
                     fMark = new Xdr.FromMarker
                     {
-                        ColumnId = new Xdr.ColumnId((moveAndSizeFromMarker.ColumnId - 1).ToString()),
-                        RowId = new Xdr.RowId((moveAndSizeFromMarker.RowId - 1).ToString()),
-                        ColumnOffset = new Xdr.ColumnOffset((moveAndSizeFromMarker.ColumnOffset + pic.Left).ToString()),
-                        RowOffset = new Xdr.RowOffset((moveAndSizeFromMarker.RowOffset + pic.Top).ToString())
+                        ColumnId = new Xdr.ColumnId((moveAndSizeFromMarker.Address.ColumnNumber - 1).ToString()),
+                        RowId = new Xdr.RowId((moveAndSizeFromMarker.Address.RowNumber - 1).ToString()),
+                        ColumnOffset = new Xdr.ColumnOffset(ConvertToEnglishMetricUnits(moveAndSizeFromMarker.Offset.X, GraphicsUtils.Graphics.DpiX).ToString()),
+                        RowOffset = new Xdr.RowOffset(ConvertToEnglishMetricUnits(moveAndSizeFromMarker.Offset.Y, GraphicsUtils.Graphics.DpiY).ToString())
                     };
 
-                    var moveAndSizeToMarker = pic.Markers.Last();
+                    var moveAndSizeToMarker = pic.Markers[Drawings.XLMarkerPosition.BottomRight];
                     tMark = new Xdr.ToMarker
                     {
-                        ColumnId = new Xdr.ColumnId((moveAndSizeToMarker.ColumnId - 1).ToString()),
-                        RowId = new Xdr.RowId((moveAndSizeToMarker.RowId - 1).ToString()),
-                        ColumnOffset = new Xdr.ColumnOffset((moveAndSizeToMarker.ColumnOffset + pic.Left).ToString()),
-                        RowOffset = new Xdr.RowOffset((moveAndSizeToMarker.RowOffset + pic.Top).ToString())
+                        ColumnId = new Xdr.ColumnId((moveAndSizeToMarker.Address.ColumnNumber - 1).ToString()),
+                        RowId = new Xdr.RowId((moveAndSizeToMarker.Address.RowNumber - 1).ToString()),
+                        ColumnOffset = new Xdr.ColumnOffset(ConvertToEnglishMetricUnits(moveAndSizeToMarker.Offset.X, GraphicsUtils.Graphics.DpiX).ToString()),
+                        RowOffset = new Xdr.RowOffset(ConvertToEnglishMetricUnits(moveAndSizeToMarker.Offset.Y, GraphicsUtils.Graphics.DpiY).ToString())
                     };
 
                     var twoCellAnchor = new Xdr.TwoCellAnchor(
@@ -2635,13 +2635,13 @@
                     break;
 
                 case Drawings.XLPicturePlacement.Move:
-                    var moveFromMarker = pic.Markers.First();
+                    var moveFromMarker = pic.Markers[Drawings.XLMarkerPosition.TopLeft];
                     fMark = new Xdr.FromMarker
                     {
-                        ColumnId = new Xdr.ColumnId((moveFromMarker.ColumnId - 1).ToString()),
-                        RowId = new Xdr.RowId((moveFromMarker.RowId - 1).ToString()),
-                        ColumnOffset = new Xdr.ColumnOffset((moveFromMarker.ColumnOffset + pic.Left).ToString()),
-                        RowOffset = new Xdr.RowOffset((moveFromMarker.RowOffset + pic.Top).ToString())
+                        ColumnId = new Xdr.ColumnId((moveFromMarker.Address.ColumnNumber - 1).ToString()),
+                        RowId = new Xdr.RowId((moveFromMarker.Address.RowNumber - 1).ToString()),
+                        ColumnOffset = new Xdr.ColumnOffset(ConvertToEnglishMetricUnits(moveFromMarker.Offset.X + pic.Left, GraphicsUtils.Graphics.DpiX).ToString()),
+                        RowOffset = new Xdr.RowOffset(ConvertToEnglishMetricUnits(moveFromMarker.Offset.Y + pic.Top, GraphicsUtils.Graphics.DpiY).ToString())
                     };
 
                     var oneCellAnchor = new Xdr.OneCellAnchor(
diff --git a/ClosedXML_Examples/ClosedXML_Examples.csproj b/ClosedXML_Examples/ClosedXML_Examples.csproj
index de7cb8e..16e493e 100644
--- a/ClosedXML_Examples/ClosedXML_Examples.csproj
+++ b/ClosedXML_Examples/ClosedXML_Examples.csproj
@@ -185,6 +185,9 @@
   <ItemGroup>
     <EmbeddedResource Include="Resources\ImageHandling.jpg" />
   </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Resources\SampleImage.jpg" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/ClosedXML_Examples/ImageHandling/ImageAnchors.cs b/ClosedXML_Examples/ImageHandling/ImageAnchors.cs
index bcd12e8..b71f37d 100644
--- a/ClosedXML_Examples/ImageHandling/ImageAnchors.cs
+++ b/ClosedXML_Examples/ImageHandling/ImageAnchors.cs
@@ -9,40 +9,68 @@
     {
         public void Create(string filePath)
         {
-            var wb = new XLWorkbook();
-            IXLWorksheet ws;
-
-            using (Stream fs = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML_Examples.Resources.ImageHandling.png"))
+            using (var wb = new XLWorkbook())
             {
-                ws = wb.Worksheets.Add("Images");
+                IXLWorksheet ws;
 
-                #region AbsoluteAnchor
+                using (Stream fs = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML_Examples.Resources.ImageHandling.png"))
+                {
+                    ws = wb.Worksheets.Add("Images1");
 
-                ws.AddPicture(fs, XLPictureFormat.Png, "Image10")
-                    .WithPlacement(XLPicturePlacement.FreeFloating)
-                    .AtPosition(220, 150);
+                    #region AbsoluteAnchor
 
-                #endregion AbsoluteAnchor
+                    ws.AddPicture(fs, XLPictureFormat.Png, "Image10")
+                        .MoveTo(220, 150);
 
-                #region OneCellAnchor
+                    #endregion AbsoluteAnchor
 
-                fs.Position = 0;
-                ws.AddPicture(fs, XLPictureFormat.Png, "Image11")
-                    .WithPlacement(XLPicturePlacement.MoveAndSize)
-                    .AtPosition(ws.Cell(1, 1));
+                    #region OneCellAnchor
 
-                #endregion OneCellAnchor
+                    fs.Position = 0;
+                    ws.AddPicture(fs, XLPictureFormat.Png, "Image11")
+                        .MoveTo(ws.Cell(1, 1).Address);
 
-                ws = wb.Worksheets.Add("MoreImages");
+                    #endregion OneCellAnchor
 
-                #region TwoCellAnchor
+                    ws = wb.Worksheets.Add("Images2");
 
-                fs.Position = 0;
-                ws.AddPicture(fs, XLPictureFormat.Png, "Image20")
-                    .WithPlacement(XLPicturePlacement.MoveAndSize)
-                    .AtPosition(ws.Cell(6, 5), ws.Cell(9, 7));
+                    #region TwoCellAnchor
 
-                #endregion TwoCellAnchor
+                    fs.Position = 0;
+                    ws.AddPicture(fs, XLPictureFormat.Png, "Image20")
+                        .MoveTo(ws.Cell(6, 5).Address, ws.Cell(9, 7).Address);
+
+                    #endregion TwoCellAnchor
+                }
+
+                using (Stream fs = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML_Examples.Resources.SampleImage.jpg"))
+                {
+                    // Moving images around and scaling them
+                    ws = wb.Worksheets.Add("Images3");
+
+                    ws.AddPicture(fs, XLPictureFormat.Jpeg)
+                        .MoveTo(ws.Cell(2, 2).Address, 20, 5, ws.Cell(5, 5).Address, 30, 10)
+                        .MoveTo(ws.Cell(2, 2).Address, ws.Cell(5, 5).Address);
+
+                    ws.AddPicture(fs, XLPictureFormat.Jpeg)
+                        .MoveTo(ws.Cell(6, 2).Address, 2, 2, ws.Cell(9, 5).Address, 2, 2)
+                        .MoveTo(ws.Cell(6, 2).Address, 20, 5, ws.Cell(9, 5).Address, 30, 10);
+
+                    ws.AddPicture(fs, XLPictureFormat.Jpeg)
+                        .MoveTo(ws.Cell(10, 2).Address, 20, 5)
+                        .Scale(0.2, true)
+                        .MoveTo(ws.Cell(10, 1).Address);
+                }
+
+                using (Stream fs = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML_Examples.Resources.SampleImage.jpg"))
+                {
+                    // Changing of placement
+                    ws = wb.Worksheets.Add("Images4");
+
+                    ws.AddPicture(fs, XLPictureFormat.Jpeg)
+                        .MoveTo(100, 100)
+                        .WithPlacement(XLPicturePlacement.FreeFloating);
+                }
 
                 wb.SaveAs(filePath);
             }
diff --git a/ClosedXML_Examples/ImageHandling/ImageFormats.cs b/ClosedXML_Examples/ImageHandling/ImageFormats.cs
index 9113df3..1f21297 100644
--- a/ClosedXML_Examples/ImageHandling/ImageFormats.cs
+++ b/ClosedXML_Examples/ImageHandling/ImageFormats.cs
@@ -18,8 +18,7 @@
 
                 ws = wb.Worksheets.Add("Jpg");
                 ws.AddPicture(fs, XLPictureFormat.Jpeg, "JpegImage")
-                    .WithPlacement(XLPicturePlacement.Move)
-                    .AtPosition(ws.Cell(1, 1));
+                    .MoveTo(ws.Cell(1, 1).Address);
 
                 #endregion Jpeg
             }
@@ -30,8 +29,7 @@
 
                 ws = wb.Worksheets.Add("Png");
                 ws.AddPicture(fs, XLPictureFormat.Png, "PngImage")
-                    .WithPlacement(XLPicturePlacement.Move)
-                    .AtPosition(ws.Cell(1, 1));
+                    .MoveTo(ws.Cell(1, 1).Address);
 
                 #endregion Png
 
diff --git a/ClosedXML_Examples/Resources/SampleImage.jpg b/ClosedXML_Examples/Resources/SampleImage.jpg
new file mode 100644
index 0000000..e7a7f75
--- /dev/null
+++ b/ClosedXML_Examples/Resources/SampleImage.jpg
Binary files differ
diff --git a/ClosedXML_Tests/ClosedXML_Tests.csproj b/ClosedXML_Tests/ClosedXML_Tests.csproj
index 558c518..47cca6a 100644
--- a/ClosedXML_Tests/ClosedXML_Tests.csproj
+++ b/ClosedXML_Tests/ClosedXML_Tests.csproj
@@ -275,7 +275,6 @@
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Resource\Images\ImageHandling.png" />
-    <EmbeddedResource Include="Resource\Images\SampleImage.jpg" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/ClosedXML_Tests/Excel/ImageHandling/PictureTests.cs b/ClosedXML_Tests/Excel/ImageHandling/PictureTests.cs
index d46217f..e0706a4 100644
--- a/ClosedXML_Tests/Excel/ImageHandling/PictureTests.cs
+++ b/ClosedXML_Tests/Excel/ImageHandling/PictureTests.cs
@@ -1,7 +1,6 @@
 using ClosedXML.Excel;
 using ClosedXML.Excel.Drawings;
 using NUnit.Framework;
-using System;
 using System.Drawing;
 using System.IO;
 using System.Linq;
@@ -13,56 +12,104 @@
     public class PictureTests
     {
         [Test]
-        public void XLMarkerTests()
-        {
-            IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
-            XLMarker firstMarker = new XLMarker
-            {
-                ColumnId = 1,
-                RowId = 1,
-                ColumnOffset = 100,
-                RowOffset = 0
-            };
-
-            firstMarker.ColumnId = 10;
-
-            Assert.AreEqual(10, firstMarker.ColumnId);
-            Assert.AreEqual(1, firstMarker.RowId);
-            Assert.AreEqual(100, firstMarker.ColumnOffset);
-            Assert.AreEqual(0, firstMarker.RowOffset);
-            //Assert.AreEqual(9, firstMarker.GetZeroBasedColumn());
-            //Assert.AreEqual(0, firstMarker.GetZeroBasedRow());
-
-            Assert.Throws(typeof(ArgumentOutOfRangeException), delegate { firstMarker.RowId = 0; });
-            Assert.Throws(typeof(ArgumentOutOfRangeException), delegate { firstMarker.ColumnId = 0; });
-            Assert.Throws(typeof(ArgumentOutOfRangeException),
-                            delegate { firstMarker.RowId = XLHelper.MaxRowNumber + 1; });
-            Assert.Throws(typeof(ArgumentOutOfRangeException),
-                            delegate { firstMarker.ColumnId = XLHelper.MaxColumnNumber + 1; });
-        }
-
-        [Test]
-        public void XLPictureTests()
+        public void CanAddPictureFromBitmap()
         {
             using (var wb = new XLWorkbook())
             {
-                var ws = wb.Worksheets.Add("Sheet1");
+                var ws = wb.AddWorksheet("Sheet1");
 
-                using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML_Tests.Resource.Images.ImageHandling.png"))
+                using (var resourceStream = Assembly.GetAssembly(typeof(ClosedXML_Examples.BasicTable)).GetManifestResourceStream("ClosedXML_Examples.Resources.SampleImage.jpg"))
+                using (var bitmap = Bitmap.FromStream(resourceStream) as Bitmap)
                 {
-                    var pic = ws.AddPicture(stream, XLPictureFormat.Png, "Image1")
+                    var picture = ws.AddPicture(bitmap, "MyPicture")
                         .WithPlacement(XLPicturePlacement.FreeFloating)
-                        .AtPosition(220, 155);
+                        .MoveTo(50, 50)
+                        .WithSize(200, 200);
 
-                    Assert.AreEqual(XLPicturePlacement.FreeFloating, pic.Placement);
-                    Assert.AreEqual("Image1", pic.Name);
-                    Assert.AreEqual(XLPictureFormat.Png, pic.Format);
+                    Assert.AreEqual(XLPictureFormat.Jpeg, picture.Format);
+                    Assert.AreEqual(200, picture.Width);
+                    Assert.AreEqual(200, picture.Height);
+                }
+            }
+        }
+
+        [Test]
+        public void CanAddPictureFromFile()
+        {
+            using (var wb = new XLWorkbook())
+            {
+                var ws = wb.AddWorksheet("Sheet1");
+
+                var path = Path.ChangeExtension(Path.GetTempFileName(), "jpg");
+
+                try
+                {
+                    using (var resourceStream = Assembly.GetAssembly(typeof(ClosedXML_Examples.BasicTable)).GetManifestResourceStream("ClosedXML_Examples.Resources.SampleImage.jpg"))
+                    using (var fileStream = File.Create(path))
+                    {
+                        resourceStream.Seek(0, SeekOrigin.Begin);
+                        resourceStream.CopyTo(fileStream);
+                        fileStream.Close();
+                    }
+
+                    var picture = ws.AddPicture(path)
+                        .WithPlacement(XLPicturePlacement.FreeFloating)
+                        .MoveTo(50, 50);
+
+                    Assert.AreEqual(XLPictureFormat.Jpeg, picture.Format);
+                    Assert.AreEqual(400, picture.Width);
+                    Assert.AreEqual(400, picture.Height);
+                }
+                finally
+                {
+                    if (File.Exists(path))
+                        File.Delete(path);
+                }
+            }
+        }
+
+        [Test]
+        public void CanScaleImage()
+        {
+            using (var wb = new XLWorkbook())
+            {
+                var ws = wb.AddWorksheet("Sheet1");
+
+                using (var resourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML_Tests.Resource.Images.ImageHandling.png"))
+                using (var bitmap = Bitmap.FromStream(resourceStream) as Bitmap)
+                {
+                    var pic = ws.AddPicture(bitmap, "MyPicture")
+                        .WithPlacement(XLPicturePlacement.FreeFloating)
+                        .MoveTo(50, 50);
+
                     Assert.AreEqual(252, pic.OriginalWidth);
                     Assert.AreEqual(152, pic.OriginalHeight);
                     Assert.AreEqual(252, pic.Width);
                     Assert.AreEqual(152, pic.Height);
-                    Assert.AreEqual(220, pic.Left);
-                    Assert.AreEqual(155, pic.Top);
+
+                    pic.ScaleHeight(0.7);
+                    pic.ScaleWidth(1.2);
+
+                    Assert.AreEqual(252, pic.OriginalWidth);
+                    Assert.AreEqual(152, pic.OriginalHeight);
+                    Assert.AreEqual(302, pic.Width);
+                    Assert.AreEqual(106, pic.Height);
+
+                    pic.ScaleHeight(0.7);
+                    pic.ScaleWidth(1.2);
+
+                    Assert.AreEqual(252, pic.OriginalWidth);
+                    Assert.AreEqual(152, pic.OriginalHeight);
+                    Assert.AreEqual(362, pic.Width);
+                    Assert.AreEqual(74, pic.Height);
+
+                    pic.ScaleHeight(0.8, true);
+                    pic.ScaleWidth(1.1, true);
+
+                    Assert.AreEqual(252, pic.OriginalWidth);
+                    Assert.AreEqual(152, pic.OriginalHeight);
+                    Assert.AreEqual(277, pic.Width);
+                    Assert.AreEqual(122, pic.Height);
                 }
             }
         }
@@ -97,96 +144,39 @@
         }
 
         [Test]
-        public void CanAddPictureFromFile()
+        public void XLMarkerTests()
         {
-            using (var wb = new XLWorkbook())
-            {
-                var ws = wb.AddWorksheet("Sheet1");
+            IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+            XLMarker firstMarker = new XLMarker(ws.Cell(1, 10).Address, new Point(100, 0));
 
-                var path = Path.ChangeExtension(Path.GetTempFileName(), "png");
-
-                using (var resourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML_Tests.Resource.Images.SampleImage.jpg"))
-                using (var fileStream = File.Create(path))
-                {
-                    resourceStream.Seek(0, SeekOrigin.Begin);
-                    resourceStream.CopyTo(fileStream);
-                    fileStream.Close();
-                }
-
-                var picture = ws.AddPicture(path)
-                    .WithPlacement(XLPicturePlacement.FreeFloating)
-                    .AtPosition(50, 50);
-
-                Assert.AreEqual(XLPictureFormat.Jpeg, picture.Format);
-                Assert.AreEqual(1365, picture.Width);
-                Assert.AreEqual(1365, picture.Height);
-            }
+            Assert.AreEqual("J", firstMarker.Address.ColumnLetter);
+            Assert.AreEqual(1, firstMarker.Address.RowNumber);
+            Assert.AreEqual(100, firstMarker.Offset.X);
+            Assert.AreEqual(0, firstMarker.Offset.Y);
         }
 
         [Test]
-        public void CanAddPictureFromBitmap()
+        public void XLPictureTests()
         {
             using (var wb = new XLWorkbook())
             {
-                var ws = wb.AddWorksheet("Sheet1");
+                var ws = wb.Worksheets.Add("Sheet1");
 
-                using (var resourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML_Tests.Resource.Images.SampleImage.jpg"))
-                using (var bitmap = Bitmap.FromStream(resourceStream) as Bitmap)
+                using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML_Tests.Resource.Images.ImageHandling.png"))
                 {
-                    var picture = ws.AddPicture(bitmap, "MyPicture")
+                    var pic = ws.AddPicture(stream, XLPictureFormat.Png, "Image1")
                         .WithPlacement(XLPicturePlacement.FreeFloating)
-                        .AtPosition(50, 50)
-                        .WithSize(200, 200);
+                        .MoveTo(220, 155);
 
-                    Assert.AreEqual(XLPictureFormat.Jpeg, picture.Format);
-                    Assert.AreEqual(200, picture.Width);
-                    Assert.AreEqual(200, picture.Height);
-                }
-            }
-        }
-
-        [Test]
-        public void CanScaleImage()
-        {
-            using (var wb = new XLWorkbook())
-            {
-                var ws = wb.AddWorksheet("Sheet1");
-
-                using (var resourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML_Tests.Resource.Images.ImageHandling.png"))
-                using (var bitmap = Bitmap.FromStream(resourceStream) as Bitmap)
-                {
-                    var pic = ws.AddPicture(bitmap, "MyPicture")
-                        .WithPlacement(XLPicturePlacement.FreeFloating)
-                        .AtPosition(50, 50);
-
+                    Assert.AreEqual(XLPicturePlacement.FreeFloating, pic.Placement);
+                    Assert.AreEqual("Image1", pic.Name);
+                    Assert.AreEqual(XLPictureFormat.Png, pic.Format);
                     Assert.AreEqual(252, pic.OriginalWidth);
                     Assert.AreEqual(152, pic.OriginalHeight);
                     Assert.AreEqual(252, pic.Width);
                     Assert.AreEqual(152, pic.Height);
-
-                    pic.ScaleHeight(0.7);
-                    pic.ScaleWidth(1.2);
-
-                    Assert.AreEqual(252, pic.OriginalWidth);
-                    Assert.AreEqual(152, pic.OriginalHeight);
-                    Assert.AreEqual(302, pic.Width);
-                    Assert.AreEqual(106, pic.Height);
-
-                    pic.ScaleHeight(0.7);
-                    pic.ScaleWidth(1.2);
-
-                    Assert.AreEqual(252, pic.OriginalWidth);
-                    Assert.AreEqual(152, pic.OriginalHeight);
-                    Assert.AreEqual(362, pic.Width);
-                    Assert.AreEqual(74, pic.Height);
-
-                    pic.ScaleHeight(0.8, true);
-                    pic.ScaleWidth(1.1, true);
-
-                    Assert.AreEqual(252, pic.OriginalWidth);
-                    Assert.AreEqual(152, pic.OriginalHeight);
-                    Assert.AreEqual(277, pic.Width);
-                    Assert.AreEqual(122, pic.Height);
+                    Assert.AreEqual(220, pic.Left);
+                    Assert.AreEqual(155, pic.Top);
                 }
             }
         }
diff --git a/ClosedXML_Tests/Resource/Examples/ImageHandling/ImageAnchors.xlsx b/ClosedXML_Tests/Resource/Examples/ImageHandling/ImageAnchors.xlsx
index 31503da..01a903c 100644
--- a/ClosedXML_Tests/Resource/Examples/ImageHandling/ImageAnchors.xlsx
+++ b/ClosedXML_Tests/Resource/Examples/ImageHandling/ImageAnchors.xlsx
Binary files differ
diff --git a/ClosedXML_Tests/Resource/Examples/ImageHandling/ImageFormats.xlsx b/ClosedXML_Tests/Resource/Examples/ImageHandling/ImageFormats.xlsx
index e4c4b0f..7beff62 100644
--- a/ClosedXML_Tests/Resource/Examples/ImageHandling/ImageFormats.xlsx
+++ b/ClosedXML_Tests/Resource/Examples/ImageHandling/ImageFormats.xlsx
Binary files differ
diff --git a/ClosedXML_Tests/Resource/Images/SampleImage.jpg b/ClosedXML_Tests/Resource/Images/SampleImage.jpg
deleted file mode 100644
index 75fa65e..0000000
--- a/ClosedXML_Tests/Resource/Images/SampleImage.jpg
+++ /dev/null
Binary files differ