diff --git a/src/Mod/Mesh/App/MeshPointPyImp.cpp b/src/Mod/Mesh/App/MeshPointPyImp.cpp
index 5e3953c09a..c94a504e96 100644
--- a/src/Mod/Mesh/App/MeshPointPyImp.cpp
+++ b/src/Mod/Mesh/App/MeshPointPyImp.cpp
@@ -35,24 +35,34 @@
 
 using namespace Mesh;
 
-// returns a string which represent the object e.g. when printed in python
+// returns a string which represents the object e.g. when printed in python
 std::string MeshPointPy::representation(void) const
 {
     MeshPointPy::PointerType ptr = getMeshPointPtr();
+    Base::Vector3d vec = *ptr;
+
     std::stringstream str;
     str << "MeshPoint (";
-    if(ptr->isBound())
-        str << ptr->x << ", "<< ptr->y << ", "<< ptr->z << ", Idx=" << ptr->Index;
-    else
-        str << ptr->x << ", "<< ptr->y << ", "<< ptr->z ;
+    if (ptr->isBound()) {
+        if (getMeshPointPtr()->Mesh->countPoints() <= getMeshPointPtr()->Index) {
+            str << vec.x << ", " << vec.y << ", " << vec.z << ", Idx=" << ptr->Index << " (Out of range)";
+        }
+        else {
+            vec = getMeshPointPtr()->Mesh->getPoint(getMeshPointPtr()->Index);
+            str << vec.x << ", " << vec.y << ", " << vec.z << ", Idx=" << ptr->Index;
+        }
+    }
+    else {
+        str << vec.x << ", " << vec.y << ", " << vec.z;
+    }
+
     str << ")";
- 
     return str.str();
 }
 
 PyObject *MeshPointPy::PyMake(struct _typeobject *, PyObject *, PyObject *)  // Python wrapper
 {
-    // create a new instance of MeshPointPy and the Twin object 
+    // create a new instance of MeshPointPy and the Twin object
     return new MeshPointPy(new MeshPoint);
 }
 
@@ -78,23 +88,35 @@ PyObject*  MeshPointPy::unbound(PyObject *args)
 
 PyObject*  MeshPointPy::move(PyObject *args)
 {
-    if (!getMeshPointPtr()->isBound())
-        PyErr_SetString(Base::BaseExceptionFreeCADError, "This object is not bounded to a mesh, so no topological operation is possible!");
+    if (!getMeshPointPtr()->isBound()) {
+        PyErr_SetString(PyExc_RuntimeError, "This object is not bounded to a mesh, so no topological operation is possible!");
+        return 0;
+    }
+    if (getMeshPointPtr()->Mesh->countPoints() <= getMeshPointPtr()->Index) {
+        PyErr_SetString(PyExc_IndexError, "Index out of range");
+        return 0;
+    }
 
     double  x=0.0,y=0.0,z=0.0;
     PyObject *object;
     Base::Vector3d vec;
-    if (PyArg_ParseTuple(args, "ddd", &x,&y,&z)) {
-        vec.Set(x,y,z);
-    } 
-    else if (PyArg_ParseTuple(args,"O!",&(Base::VectorPy::Type), &object)) {
+
+    do {
+        if (PyArg_ParseTuple(args, "ddd", &x,&y,&z)) {
+            vec.Set(x,y,z);
+            break;
+        }
+
         PyErr_Clear(); // set by PyArg_ParseTuple()
-        // Note: must be static_cast, not reinterpret_cast
-        vec = *(static_cast<Base::VectorPy*>(object)->getVectorPtr());
-    }
-    else {
+        if (PyArg_ParseTuple(args,"O!",&(Base::VectorPy::Type), &object)) {
+            vec = *(static_cast<Base::VectorPy*>(object)->getVectorPtr());
+            break;
+        }
+
+        PyErr_SetString(PyExc_TypeError, "Tuple of three floats or Vector expected");
         return 0;
     }
+    while (false);
 
     getMeshPointPtr()->Mesh->movePoint(getMeshPointPtr()->Index,vec);
     Py_Return;
@@ -113,7 +135,9 @@ Py::Boolean MeshPointPy::getBound(void) const
 Py::Object MeshPointPy::getNormal(void) const
 {
     if (!getMeshPointPtr()->isBound())
-        PyErr_SetString(Base::BaseExceptionFreeCADError, "This object is not bounded to a mesh, so no topological operation is possible!");
+        throw Py::RuntimeError("This object is not bound to a mesh, so no topological operation is possible!");
+    if (getMeshPointPtr()->Mesh->countPoints() <= getMeshPointPtr()->Index)
+        throw Py::IndexError("Index out of range");
 
     Base::Vector3d* v = new Base::Vector3d(getMeshPointPtr()->Mesh->getPointNormal(getMeshPointPtr()->Index));
     Base::VectorPy* normal = new Base::VectorPy(v);
@@ -123,8 +147,8 @@ Py::Object MeshPointPy::getNormal(void) const
 
 Py::Object MeshPointPy::getVector(void) const
 {
-    MeshPointPy::PointerType ptr = reinterpret_cast<MeshPointPy::PointerType>(_pcTwinPointer);
-    
+    MeshPointPy::PointerType ptr = static_cast<MeshPointPy::PointerType>(_pcTwinPointer);
+
     Base::VectorPy* vec = new Base::VectorPy(*ptr);
     vec->setConst();
     return Py::Object(vec,true);
@@ -132,49 +156,73 @@ Py::Object MeshPointPy::getVector(void) const
 
 Py::Float MeshPointPy::getx(void) const
 {
-    MeshPointPy::PointerType ptr = reinterpret_cast<MeshPointPy::PointerType>(_pcTwinPointer);
-    return Py::Float(ptr->x);
+    MeshPointPy::PointerType ptr = static_cast<MeshPointPy::PointerType>(_pcTwinPointer);
+    double x = ptr->x;
+
+    if (getMeshPointPtr()->isBound()) {
+        if (getMeshPointPtr()->Mesh->countPoints() > getMeshPointPtr()->Index)
+            x = getMeshPointPtr()->Mesh->getPoint(getMeshPointPtr()->Index).x;
+    }
+
+    return Py::Float(x);
 }
 
 void  MeshPointPy::setx(Py::Float arg)
 {
-    MeshPointPy::PointerType ptr = reinterpret_cast<MeshPointPy::PointerType>(_pcTwinPointer);
+    MeshPointPy::PointerType ptr = static_cast<MeshPointPy::PointerType>(_pcTwinPointer);
     ptr->x = (double)arg;
 
     if (getMeshPointPtr()->isBound()) {
-        getMeshPointPtr()->Mesh->movePoint(getMeshPointPtr()->Index,*ptr);
+        if (getMeshPointPtr()->Mesh->countPoints() > getMeshPointPtr()->Index)
+            getMeshPointPtr()->Mesh->setPoint(getMeshPointPtr()->Index,*ptr);
     }
 }
 
 Py::Float MeshPointPy::gety(void) const
 {
-    MeshPointPy::PointerType ptr = reinterpret_cast<MeshPointPy::PointerType>(_pcTwinPointer);
-    return Py::Float(ptr->y);
+    MeshPointPy::PointerType ptr = static_cast<MeshPointPy::PointerType>(_pcTwinPointer);
+    double y = ptr->y;
+
+    if (getMeshPointPtr()->isBound()) {
+        if (getMeshPointPtr()->Mesh->countPoints() > getMeshPointPtr()->Index)
+            y = getMeshPointPtr()->Mesh->getPoint(getMeshPointPtr()->Index).y;
+    }
+
+    return Py::Float(y);
 }
 
 void  MeshPointPy::sety(Py::Float arg)
 {
-    MeshPointPy::PointerType ptr = reinterpret_cast<MeshPointPy::PointerType>(_pcTwinPointer);
+    MeshPointPy::PointerType ptr = static_cast<MeshPointPy::PointerType>(_pcTwinPointer);
     ptr->y = (double)arg;
 
     if (getMeshPointPtr()->isBound()) {
-        getMeshPointPtr()->Mesh->movePoint(getMeshPointPtr()->Index,*ptr);
+        if (getMeshPointPtr()->Mesh->countPoints() > getMeshPointPtr()->Index)
+            getMeshPointPtr()->Mesh->setPoint(getMeshPointPtr()->Index,*ptr);
     }
 }
 
 Py::Float MeshPointPy::getz(void) const
 {
-    MeshPointPy::PointerType ptr = reinterpret_cast<MeshPointPy::PointerType>(_pcTwinPointer);
-    return Py::Float(ptr->z);
+    MeshPointPy::PointerType ptr = static_cast<MeshPointPy::PointerType>(_pcTwinPointer);
+    double z = ptr->z;
+
+    if (getMeshPointPtr()->isBound()) {
+        if (getMeshPointPtr()->Mesh->countPoints() > getMeshPointPtr()->Index)
+            z = getMeshPointPtr()->Mesh->getPoint(getMeshPointPtr()->Index).z;
+    }
+
+    return Py::Float(z);
 }
 
 void  MeshPointPy::setz(Py::Float arg)
 {
-    MeshPointPy::PointerType ptr = reinterpret_cast<MeshPointPy::PointerType>(_pcTwinPointer);
+    MeshPointPy::PointerType ptr = static_cast<MeshPointPy::PointerType>(_pcTwinPointer);
     ptr->z = (double)arg;
 
     if (getMeshPointPtr()->isBound()) {
-        getMeshPointPtr()->Mesh->movePoint(getMeshPointPtr()->Index,*ptr);
+        if (getMeshPointPtr()->Mesh->countPoints() > getMeshPointPtr()->Index)
+            getMeshPointPtr()->Mesh->setPoint(getMeshPointPtr()->Index,*ptr);
     }
 }
 
@@ -185,5 +233,5 @@ PyObject *MeshPointPy::getCustomAttributes(const char* /*attr*/) const
 
 int MeshPointPy::setCustomAttributes(const char* /*attr*/, PyObject* /*obj*/)
 {
-    return 0; 
+    return 0;
 }