add files to repo

Author: petercorke

examples/morphdemo.py

@@ -0,0 +1,109 @@
+'''%MORPHDEMO Demonstrate morphology using animation
+%
+% MORPHDEMO(IM, SE, OPTIONS) displays an animation to show the principles
+% of the mathematical morphology operations dilation or erosion.  Two
+% windows are displayed side by side, input binary image on the left and
+% output image on the right.  The structuring element moves over the input
+% image and is colored red if the result is zero, else blue.  Pixels in
+% the output image are initially all grey but change to black or white
+% as the structuring element moves.
+%
+% OUT = MORPHDEMO(IM, SE, OPTIONS) as above but returns the output image.
+%
+% Options::
+% 'dilate'      Perform morphological dilation
+% 'erode'       Perform morphological erosion
+% 'delay'       Time between animation frames (default 0.5s)
+% 'scale',S     Scale factor for output image (default 64)
+% 'movie',M     Write image frames to the folder M
+%
+% Notes::
+% - This is meant for small images, say 10x10 pixels.
+%
+% See also IMORPH, IDILATE, IERODE.
+'''
+
+def morphdemo(input, se, op='erode', delay=0.1, scale=64):
+
+    print("hello from morphdemo")
+    
+    # # movie option
+    
+    # input = idouble(input>0);
+    
+    # clf
+
+    # %se = [0 1 0; 1 1 1; 0 1 0];
+    
+    # white = [1 1 1] * 0.5;
+    # red = [1 0 0] * 0.8;
+    # blue = [0 0 1] * 0.8;
+    
+    # result = ones(size(input)) * 0.5;
+    
+    # subplot(121);
+    # h1 = gca;
+    # im = icolor(input);
+    # h1 = image(im);
+    # set(h1, 'CDataMapping', 'direct');
+    # axis equal
+    
+    # subplot(122);
+    # h2 = image(result);
+    # colormap(gray);
+    # set(h2, 'CDataMapping', 'scaled');
+    # set(gca, 'CLim', [0 1]);
+    # set(gca, 'CLimMode', 'manual');
+    # axis equal
+    
+    # nr_se = (numrows(se)-1)/2;
+    # nc_se = (numcols(se)-1)/2;
+    
+    # for r=nr_se+1:numrows(input)-nr_se
+    #     for c=nc_se+1:numcols(input)-nc_se
+    #         im = icolor(input*0.7);
+            
+    #         win = input(r-nr_se:r+nr_se, c-nc_se:c+nc_se);
+            
+    #         rr = win .* se;
+    #         switch opt.op
+    #             case {'erode', 'min'}
+    #             if all(rr(find(se)))
+    #                 color = blue;
+    #                 result(r,c) = 1;
+    #             else
+    #                 color = red;
+    #                 result(r,c) = 0;
+    #             end
+    #             case {'dilate', 'max'}
+    #             if any(rr(find(se)))
+    #                 color = blue;
+    #                 result(r,c) = 1;
+    #             else
+    #                 color = red;
+    #                 result(r,c) = 0;
+
+            
+    #         for i=-nr_se:nr_se
+    #             for j=-nc_se:nc_se
+    #                 if se(i+nr_se+1,j+nc_se+1) > 0
+    #                     im(r+i,c+j,:) = min(1, im(r+i,c+j,:) + reshape(color, [1 1 3]));
+
+            
+    #         set(h1, 'CData', im);
+            
+    #         set(h2, 'CData', result);
+            
+    #         if isempty(opt.movie)
+    #             pause(opt.delay);
+    #         else
+    #             frame1 = ireplicate(im, opt.scale);
+    #             frame2 = ireplicate(icolor(result), opt.scale);
+    #             frame = cat(2, frame1, frame2);
+    #             imwrite(frame, sprintf('%s/%04d.png', opt.movie, framenum));
+    #             framenum = framenum+1;    
+
+    
+    # if nargout > 0
+    #     out = result > 0.6;
+    # end

examples/ransac_line.py

@@ -0,0 +1,35 @@
+import numpy as np
+
+def ransac_line(x, y, npoints=2, maxiter=20, t=1e-6, d=4):
+
+    iterations = 0
+    n = len(x)
+    best_fit = np.inf
+    best_model = None
+
+    while True:
+        inliers = list(np.random.randint(0, len(x), npoints))
+
+        m, c, r2, *_ = sp.stats.linregress(x[inliers], y[inliers])
+        new_inliers = []
+        for k in range(len(x)):
+            if k in inliers:
+                continue
+            if np.linalg.norm(m * x[k] + c - y[k]) < t:
+                new_inliers.append(k)
+
+        inliers.extend(new_inliers)
+        if len(inliers) >= d:
+            # decent model
+            m, c, r2, *_ = sp.stats.linregress(x[inliers], y[inliers])
+            err = np.linalg.norm(m * x[inliers] + c - y[inliers])
+            if err < best_fit:
+                best_fit = err
+                best_model = (m, c)
+                best_inliers = inliers
+
+        iterations += 1
+        if iterations > maxiter:
+            break
+    
+    return best_model, best_inliers

machinevisiontoolbox/blocks/test_blocks.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+
+from bdsim.blocks.linalg import *
+
+import unittest
+import numpy.testing as nt
+
+from machinevisiontoolbox import CentralCamera, mkcube
+from spatialmath import SE3
+
+from machinevisiontoolbox.blocks import *
+
+
+class CameraBlockTest(unittest.TestCase):
+    def test_camera(self):
+
+        cam = CentralCamera.Default()
+        block = Camera(cam)
+
+        P = np.array([1, 2, 5])
+        T = SE3()
+        p = cam.project_point(P, pose=T)
+
+        nt.assert_array_almost_equal(block._output(P, T)[0], p)
+
+        T = SE3.Trans(0.2, 0.3, 0.4)
+        p = cam.project_point(P, pose=T)
+
+        nt.assert_array_almost_equal(block._output(P, T)[0], p)
+
+    def test_visjac(self):
+
+        cam = CentralCamera.Default()
+        block = Visjac_p(cam, 5)
+
+        P = np.array([1, 2, 5])
+        p = cam.project_point(P)
+
+        J = cam.visjac_p(p, 5)
+        nt.assert_array_almost_equal(block._output(p)[0], J)
+
+    def test_estpose(self):
+
+        cam = CentralCamera.Default()
+
+        P = mkcube(0.2)
+        T_unknown = SE3.Trans(0.1, 0.2, 1.5) * SE3.RPY(0.1, 0.2, 0.3)
+        p = cam.project_point(P, objpose=T_unknown)
+
+        T_est = cam.estpose(P, p)
+
+        block = EstPose_p(cam, P)
+
+        nt.assert_array_almost_equal(block._output(p)[0], T_est)
+
+    def test_imageplane(self):
+
+        cam = CentralCamera.Default()
+        block = ImagePlane(cam)
+
+        # block._start()
+        # block._step()
+
+
+# ---------------------------------------------------------------------------------------#
+if __name__ == "__main__":
+
+    unittest.main()