diff --git a/.gitattributes b/.gitattributes
index 940a331..1f1d989 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -151,6 +151,8 @@ icons/volume_raycasting.png -text
 icons/volume_raycasting_original.png -text
 icons/zh_TW.bmp -text
 invesalius/.svnignore -text
+invesalius/data/bases.py -text
+invesalius/data/co_registration.py -text
 locale/de/LC_MESSAGES/invesalius.mo -text
 locale/el/LC_MESSAGES/invesalius.mo -text
 locale/en/LC_MESSAGES/invesalius.mo -text
diff --git a/invesalius/data/bases.py b/invesalius/data/bases.py
new file mode 100644
index 0000000..9e2c3fd
--- /dev/null
+++ b/invesalius/data/bases.py
@@ -0,0 +1,85 @@
+from numpy import *
+from math import sqrt
+
+class Bases:
+    
+    def __init__(self, p1, p2, p3):
+                
+        self.p1 = array([p1[0], p1[1], p1[2]])
+        self.p2 = array([p2[0], p2[1], p2[2]])
+        self.p3 = array([p3[0], p3[1], p3[2]])
+        
+        print "p1: ", self.p1
+        print "p2: ", self.p2
+        print "p3: ", self.p3
+
+        self.sub1 = self.p2 - self.p1
+        self.sub2 = self.p3 - self.p1
+        
+    def Basecreation(self):
+        #g1
+        g1 = self.sub1
+        
+        #g2
+        lamb1 = g1[0]*self.sub2[0] + g1[1]*self.sub2[1] + g1[2]*self.sub2[2]
+        lamb2 = dot(g1, g1)
+        lamb = lamb1/lamb2
+        
+        #Ponto q    
+        q = self.p1 + lamb*self.sub1
+         
+        #g1 e g2 com origem em q   
+        g1 = self.p1 - q
+        g2 = self.p3 - q
+        
+        #testa se o g1 nao eh um vetor nulo
+        if g1.any() == False:
+            g1 = self.p2 - q
+            
+        #g3 - Produto vetorial NumPy
+        g3 = cross(g2, g1)
+        
+        #normalizacao dos vetores
+        g1 = g1/sqrt(lamb2)
+        g2 = g2/sqrt(dot(g2, g2))
+        g3 = g3/sqrt(dot(g3, g3))
+            
+        M = matrix([[g1[0],g1[1],g1[2]], [g2[0],g2[1],g2[2]], [g3[0],g3[1],g3[2]]])
+        q.shape = (3, 1)
+        q = matrix(q.copy())
+        print"M: ", M
+        print
+        print"q: ", q
+        print
+        Minv = M.I
+        
+        return M, q, Minv
+    
+def FlipX(point):
+        
+        point = matrix(point + (0,))
+               
+        #inverter o eixo z
+        ## possivel explicacaoo -- origem do eixo do imagedata esta no canto
+        ## superior esquerdo e origem da superfice eh no canto inferior esquerdo
+        ## ou a ordem de empilhamento das fatias
+        
+        point[0, 2] = -point[0, 2]
+        
+        #Flip em y
+        Mrot = matrix([[1.0, 0.0, 0.0, 0.0],
+                             [0.0, -1.0, 0.0, 0.0],
+                             [0.0, 0.0, -1.0, 0.0],
+                             [0.0, 0.0, 0.0, 1.0]])
+        Mtrans = matrix([[1.0, 0, 0, -point[0, 0]],
+                               [0.0, 1.0, 0, -point[0, 1]],
+                               [0.0, 0.0, 1.0, -point[0, 2]],
+                               [0.0, 0.0, 0.0, 1.0]])
+        Mtrans_return = matrix([[1.0, 0, 0, point[0, 0]],
+                               [0.0, 1.0, 0, point[0, 1]],
+                               [0.0, 0.0, 1.0, point[0, 2]],
+                               [0.0, 0.0, 0.0, 1.0]])
+        
+        point_rot = point*Mtrans*Mrot*Mtrans_return
+        x, y, z  = point_rot.tolist()[0][:3]
+        return x, y, z
diff --git a/invesalius/data/co_registration.py b/invesalius/data/co_registration.py
new file mode 100644
index 0000000..0dd1cf1
--- /dev/null
+++ b/invesalius/data/co_registration.py
@@ -0,0 +1,83 @@
+import threading
+import serial
+import wx.lib.pubsub as ps
+from numpy import *
+from math import sqrt
+from time import sleep
+import project
+
+class Corregister(threading.Thread):
+    
+    def __init__(self, bases, flag):
+        
+        threading.Thread.__init__(self)
+        self.M = bases[0]
+        self.Minv = bases[1]
+        self.N = bases[2]
+        self.Ninv = bases[3]
+        self.q1 = bases[4]
+        self.q2 = bases[5]
+        self.flag = flag
+        self._pause_ = 0
+        self.start()
+        
+    def stop(self):
+        # Stop neuronavigation
+        self._pause_ = 1
+        
+    def Coordinates(self):        
+        #Get Polhemus points for neuronavigation       
+        ser = serial.Serial(0)
+        ser.write("Y")       
+        ser.write("P")
+        str = ser.readline()
+        ser.write("Y")
+        str = str.replace("\r\n","")
+        str = str.replace("-"," -")
+        aostr = [s for s in str.split()]
+        #aoflt -> 0:letter 1:x 2:y 3:z
+        aoflt = [float(aostr[1]), float(aostr[2]), float(aostr[3]),
+                  float(aostr[4]), float(aostr[5]), float(aostr[6])]      
+        ser.close()
+        
+        #Unit change: inches to millimeters
+        x = 25.4
+        y = 25.4
+        z = -25.4
+
+        coord = (aoflt[0]*x, aoflt[1]*y, aoflt[2]*z)
+        return coord
+       
+    def run(self):
+        #Image limits to use in simulation
+        #bounds = array(project.Project().imagedata.GetBounds())
+        #im_simu = bounds
+        #im_simu[0] = bounds[0] - 10.0
+        #im_simu[2] = bounds[2] - 10.0
+        #im_simu[4] = bounds[4] - 10.0
+        
+        while self.flag == True:
+            #Neuronavigation with Polhemus
+            trck = self.Coordinates()
+            tracker = matrix([[trck[0]], [trck[1]], [trck[2]]])            
+            img = self.q1 + (self.Minv*self.N)*(tracker - self.q2)
+            coord = [float(img[0]), float(img[1]), float(img[2])]
+            ps.Publisher().sendMessage('Co-registered Points', coord)
+
+            if self._pause_:
+                return
+            
+            #Loop for simulate Polhemus movement and Neuronavigation
+            #for i in range(0, 5, 2):
+            #    while im_simu[i] < (bounds[i+1]+10.0):
+            #        im_init = matrix([[im_simu[0]], [im_simu[2]], [im_simu[4]]])          
+            #        #mudanca coordenada img2plh
+            #        tr_simu = self.q2 + (self.Ninv*self.M)*(im_init - self.q1)
+            #        #mudanca coordenada plh2img
+            #        img_final = self.q1 + (self.Minv*self.N)*(tr_simu - self.q2)
+            #        #publica as alteracoes que devem ser feitas nas fatias
+            #        coord = [float(img_final[0]), float(img_final[1]), float(img_final[2])]
+            #        ps.Publisher().sendMessage('Co-registered Points', coord)
+            #        im_simu[i] = im_simu[i] + 4.0
+            #        if self._pause_:
+            #            return
--
libgit2 0.21.2