OdGeMatrix2d.cs

Go to the documentation of this file.

//------------------------------------------------------------------------------
// <auto-generated />
//
// This file was automatically generated by SWIG (http://www.swig.org).
// Version 4.0.2
//
// Do not make changes to this file unless you know what you are doing--modify
// the SWIG interface file instead.
//------------------------------------------------------------------------------
 
namespace Teigha.Core {
 
using System;
using System.Runtime.InteropServices;
 
public class OdGeMatrix2d : global::System.IDisposable {
  private Object locker = new Object();
  private HandleRef swigCPtr;
  protected bool swigCMemOwn;
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
  public OdGeMatrix2d(IntPtr cPtr, bool cMemoryOwn) {
    swigCMemOwn = cMemoryOwn;
    swigCPtr = new HandleRef(this, cPtr);
  }
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
  public static HandleRef getCPtr(OdGeMatrix2d obj) {
    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
  }
 
  ~OdGeMatrix2d() {
    Dispose(false);
  }
 
  public void Dispose() {
    Dispose(true);
    global::System.GC.SuppressFinalize(this);
  }
 
  protected virtual void Dispose(bool disposing) {
    lock(this) {
      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
        if (swigCMemOwn) {
          swigCMemOwn = false;
          GlobalsPINVOKE.delete_OdGeMatrix2d(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
    }
  }
 
  public OdGeMatrix2d() : this(GlobalsPINVOKE.new_OdGeMatrix2d(), MemoryManager.GetMemoryManager().GetCurrentTransaction() == null) {
        MemoryTransaction mTr = MemoryManager.GetMemoryManager().GetCurrentTransaction(); // MemoryTransaction #40
        if (null != mTr)
        {
                mTr.AddObject(new OdGeMatrix2d(swigCPtr.Handle, true));
        }
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
  }
  public double this[int row, int column]
  {
    get { return GetItem(row, column); }
    set 
    { 
      GlobalsPINVOKE.OdGeMatrix2d_entry_set(swigCPtr, row, column, value);
    }
  }
 
  public static OdGeMatrix2d operator *(OdGeMatrix2d m, OdGeMatrix2d d)
  {
    return m.Mul(d);
  }
  public static OdGePoint2d operator *(OdGeMatrix2d matrix, OdGePoint2d point)
  {
    return Globals.Mul(matrix, point);
  }
  public static OdGeVector2d operator *(OdGeMatrix2d matrix, OdGeVector2d vect)
  {
    return Globals.Mul(matrix, vect);
  }
 
  public static OdGeMatrix2d kIdentity {
    get {
      global::System.IntPtr cPtr = GlobalsPINVOKE.OdGeMatrix2d_kIdentity_get();
      OdGeMatrix2d ret = (cPtr == global::System.IntPtr.Zero) ? null : new OdGeMatrix2d(cPtr, false);
      if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } 
  }
 
  public OdGeMatrix2d setToIdentity() {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_setToIdentity(swigCPtr); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public OdGeMatrix2d Mul(OdGeMatrix2d matrix) {
    OdGeMatrix2d ret = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_Mul__SWIG_0(swigCPtr, OdGeMatrix2d.getCPtr(matrix)), true);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdGeMatrix2d preMultBy(OdGeMatrix2d leftSide) {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_preMultBy(swigCPtr, OdGeMatrix2d.getCPtr(leftSide)); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public OdGeMatrix2d postMultBy(OdGeMatrix2d rightSide) {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_postMultBy(swigCPtr, OdGeMatrix2d.getCPtr(rightSide)); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public OdGeMatrix2d setToProduct(OdGeMatrix2d matrix1, OdGeMatrix2d matrix2) {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_setToProduct(swigCPtr, OdGeMatrix2d.getCPtr(matrix1), OdGeMatrix2d.getCPtr(matrix2)); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public OdGeMatrix2d invert() {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_invert(swigCPtr); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public OdGeMatrix2d inverse() {
    OdGeMatrix2d ret = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_inverse(swigCPtr), true);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool isSingular(OdGeTol tol) {
    bool ret = GlobalsPINVOKE.OdGeMatrix2d_isSingular__SWIG_0(swigCPtr, OdGeTol.getCPtr(tol));
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool isSingular() {
    bool ret = GlobalsPINVOKE.OdGeMatrix2d_isSingular__SWIG_1(swigCPtr);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdGeMatrix2d transposeIt() {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_transposeIt(swigCPtr); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public OdGeMatrix2d transpose() {
    OdGeMatrix2d ret = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_transpose(swigCPtr), true);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool IsEqual(OdGeMatrix2d matrix) {
    bool ret = GlobalsPINVOKE.OdGeMatrix2d_IsEqual(swigCPtr, OdGeMatrix2d.getCPtr(matrix));
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool IsNotEqual(OdGeMatrix2d matrix) {
    bool ret = GlobalsPINVOKE.OdGeMatrix2d_IsNotEqual(swigCPtr, OdGeMatrix2d.getCPtr(matrix));
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool isEqualTo(OdGeMatrix2d matrix, OdGeTol tol) {
    bool ret = GlobalsPINVOKE.OdGeMatrix2d_isEqualTo__SWIG_0(swigCPtr, OdGeMatrix2d.getCPtr(matrix), OdGeTol.getCPtr(tol));
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool isEqualTo(OdGeMatrix2d matrix) {
    bool ret = GlobalsPINVOKE.OdGeMatrix2d_isEqualTo__SWIG_1(swigCPtr, OdGeMatrix2d.getCPtr(matrix));
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool isUniScaledOrtho(OdGeTol tol) {
    bool ret = GlobalsPINVOKE.OdGeMatrix2d_isUniScaledOrtho__SWIG_0(swigCPtr, OdGeTol.getCPtr(tol));
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool isUniScaledOrtho() {
    bool ret = GlobalsPINVOKE.OdGeMatrix2d_isUniScaledOrtho__SWIG_1(swigCPtr);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool isScaledOrtho(OdGeTol tol) {
    bool ret = GlobalsPINVOKE.OdGeMatrix2d_isScaledOrtho__SWIG_0(swigCPtr, OdGeTol.getCPtr(tol));
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool isScaledOrtho() {
    bool ret = GlobalsPINVOKE.OdGeMatrix2d_isScaledOrtho__SWIG_1(swigCPtr);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public double scale() {
    double ret = GlobalsPINVOKE.OdGeMatrix2d_scale(swigCPtr);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public double det() {
    double ret = GlobalsPINVOKE.OdGeMatrix2d_det(swigCPtr);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdGeMatrix2d setTranslation(OdGeVector2d vect) {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_setTranslation(swigCPtr, OdGeVector2d.getCPtr(vect).Handle); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public OdGeVector2d translation() {
    OdGeVector2d ret = new OdGeVector2d(GlobalsPINVOKE.OdGeMatrix2d_translation__SWIG_0(swigCPtr), true);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public static OdGeMatrix2d translation(OdGeVector2d vector) {
    OdGeMatrix2d ret = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_translation__SWIG_1(OdGeVector2d.getCPtr(vector).Handle), true);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool isConformal(out double scale, out double angle, out bool isMirror, OdGeVector2d reflex) {
    bool ret = GlobalsPINVOKE.OdGeMatrix2d_isConformal(swigCPtr, out scale, out angle, out isMirror, OdGeVector2d.getCPtr(reflex).Handle);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdGeMatrix2d setCoordSystem(OdGePoint2d origin, OdGeVector2d xAxis, OdGeVector2d yAxis) {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_setCoordSystem(swigCPtr, OdGePoint2d.getCPtr(origin), OdGeVector2d.getCPtr(xAxis).Handle, OdGeVector2d.getCPtr(yAxis).Handle); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public void getCoordSystem(OdGePoint2d origin, OdGeVector2d xAxis, OdGeVector2d yAxis) {
    GlobalsPINVOKE.OdGeMatrix2d_getCoordSystem(swigCPtr, OdGePoint2d.getCPtr(origin), OdGeVector2d.getCPtr(xAxis).Handle, OdGeVector2d.getCPtr(yAxis).Handle);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGeMatrix2d setToTranslation(OdGeVector2d vect) {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_setToTranslation(swigCPtr, OdGeVector2d.getCPtr(vect).Handle); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public OdGeMatrix2d setToRotation(double angle, OdGePoint2d center) {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_setToRotation__SWIG_0(swigCPtr, angle, OdGePoint2d.getCPtr(center)); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public OdGeMatrix2d setToRotation(double angle) {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_setToRotation__SWIG_1(swigCPtr, angle); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public OdGeMatrix2d setToScaling(double scale, OdGePoint2d center) {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_setToScaling__SWIG_0(swigCPtr, scale, OdGePoint2d.getCPtr(center)); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public OdGeMatrix2d setToScaling(double scale) {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_setToScaling__SWIG_1(swigCPtr, scale); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public OdGeMatrix2d setToScaling(OdGeScale2d scale, OdGePoint2d center) {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_setToScaling__SWIG_2(swigCPtr, OdGeScale2d.getCPtr(scale), OdGePoint2d.getCPtr(center)); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public OdGeMatrix2d setToScaling(OdGeScale2d scale) {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_setToScaling__SWIG_3(swigCPtr, OdGeScale2d.getCPtr(scale)); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public OdGeMatrix2d setToMirroring(OdGePoint2d mirrorPoint) {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_setToMirroring__SWIG_0(swigCPtr, OdGePoint2d.getCPtr(mirrorPoint)); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public OdGeMatrix2d setToMirroring(OdGeLine2d mirrorLine) {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_setToMirroring__SWIG_1(swigCPtr, OdGeLine2d.getCPtr(mirrorLine)); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public OdGeMatrix2d setToAlignCoordSys(OdGePoint2d fromOrigin, OdGeVector2d fromXAxis, OdGeVector2d fromYAxis, OdGePoint2d toOrigin, OdGeVector2d toXAxis, OdGeVector2d toYAxis) {
        OdGeMatrix2d ret = new OdGeMatrix2d();
        GlobalsPINVOKE.OdGeMatrix2d_setToAlignCoordSys(swigCPtr, OdGePoint2d.getCPtr(fromOrigin), OdGeVector2d.getCPtr(fromXAxis).Handle, OdGeVector2d.getCPtr(fromYAxis).Handle, OdGePoint2d.getCPtr(toOrigin), OdGeVector2d.getCPtr(toXAxis).Handle, OdGeVector2d.getCPtr(toYAxis).Handle); 
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
        for (int i = 0; i < 3; i++)
        {
                for (int j = 0; j < 3; j++)
                {
                        ret[i,j] = this[i,j];
                }
        }
        return ret;
}
 
  public static OdGeMatrix2d rotation(double angle, OdGePoint2d center) {
    OdGeMatrix2d ret = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_rotation__SWIG_0(angle, OdGePoint2d.getCPtr(center)), true);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public static OdGeMatrix2d rotation(double angle) {
    OdGeMatrix2d ret = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_rotation__SWIG_1(angle), true);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public static OdGeMatrix2d scaling(double scale, OdGePoint2d center) {
    OdGeMatrix2d ret = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_scaling__SWIG_0(scale, OdGePoint2d.getCPtr(center)), true);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public static OdGeMatrix2d scaling(double scale) {
    OdGeMatrix2d ret = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_scaling__SWIG_1(scale), true);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public static OdGeMatrix2d scaling(OdGeScale2d scale, OdGePoint2d center) {
    OdGeMatrix2d ret = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_scaling__SWIG_2(OdGeScale2d.getCPtr(scale), OdGePoint2d.getCPtr(center)), true);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public static OdGeMatrix2d scaling(OdGeScale2d scale) {
    OdGeMatrix2d ret = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_scaling__SWIG_3(OdGeScale2d.getCPtr(scale)), true);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public static OdGeMatrix2d mirroring(OdGePoint2d mirrorPoint) {
    OdGeMatrix2d ret = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_mirroring__SWIG_0(OdGePoint2d.getCPtr(mirrorPoint)), true);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public static OdGeMatrix2d mirroring(OdGeLine2d mirrorLine) {
    OdGeMatrix2d ret = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_mirroring__SWIG_1(OdGeLine2d.getCPtr(mirrorLine)), true);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public static OdGeMatrix2d alignCoordSys(OdGePoint2d fromOrigin, OdGeVector2d fromXAxis, OdGeVector2d fromYAxis, OdGePoint2d toOrigin, OdGeVector2d toXAxis, OdGeVector2d toYAxis) {
    OdGeMatrix2d ret = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_alignCoordSys(OdGePoint2d.getCPtr(fromOrigin), OdGeVector2d.getCPtr(fromXAxis).Handle, OdGeVector2d.getCPtr(fromYAxis).Handle, OdGePoint2d.getCPtr(toOrigin), OdGeVector2d.getCPtr(toXAxis).Handle, OdGeVector2d.getCPtr(toYAxis).Handle), true);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public double GetItem(int row, int column) {
    double ret = GlobalsPINVOKE.OdGeMatrix2d_GetItem(swigCPtr, row, column);
    if (GlobalsPINVOKE.SWIGPendingException.Pending) throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
     public  static  Teigha.Core.OdGeMatrix2d vb_rotation(double angle, Teigha.Core.OdGePoint2d center) { return rotation(angle, center); }
  
     public  static  Teigha.Core.OdGeMatrix2d vb_rotation(double angle) { return rotation(angle); }
  
}
 
}