Create Python Application with Multiple MATLAB Functions

Supported platforms: Windows^®, Linux^®, Mac

This example shows how to create a Python^® application that uses multiple MATLAB^® functions to compute data from a rectangle.

Prerequisites

Verify that you have a version of Python installed that is compatible with MATLAB Compiler SDK™. For details, see MATLAB Supported Interfaces to Other Languages.

This example uses the following files in matlabroot\extern\examples\compilersdk\python\rectangle\:

MATLAB Functions	`getPointCoordinates.m` `getRectangleArea.m` `getRectangleCorners.m` `getRectangleHeight.m` `getRectangleWidth.m` `makePoint.m` `makeRectangle.m` `Point.m` `Rectangle.m` `rectangleDemo.m`
Python Application Code	`rectangleDriver.py`

Create and Run Python Application

At the MATLAB command prompt, copy the rectangle folder that ships with MATLAB to your work folder.
```
copyfile(fullfile(matlabroot,"extern","examples", ...
"compilersdk","python","rectangle"),"rectangle");
```
Navigate to the new rectangle folder in your work folder.

Examine the MATLAB function rectangleDemo.m.

The function creates two Point objects, then creates a Rectangle object using the points as corners. It then calculates and displays data about the rectangle.

function rectangleDemo()
    % RECTANGLEDEMO Construct a rectangle and print information about it

    pointZeroZero = makePoint(0, 0);
    pointThreeFour = makePoint(3, 4);
    rectA = makeRectangle(pointZeroZero, pointThreeFour);
    corners = getRectangleCorners(rectA);
    showPointCoordinates(corners.upperLeft, 'Upper left-hand corner');
    showPointCoordinates(corners.lowerLeft, 'Lower left-hand corner');
    showPointCoordinates(corners.upperRight, 'Upper right-hand corner');
    showPointCoordinates(corners.lowerRight, 'Lower right-hand corner');
    fprintf('Area: %.1f\n', area(rectA));
    fprintf('Height: %.1f\n', height(rectA));
    fprintf('Width: %.1f\n', width(rectA));
end

% This is an auxiliary function. It cannot be called outside rectangleDemo().
function showPointCoordinates(pt, desc)
    coordinates = getPointCoordinates(pt);
    fprintf('%s: (%.1f, %.1f)\n', desc, coordinates.X, coordinates.Y);
end

Build a Python package named rectangleLib using all of the MATLAB function files in the rectangle folder.
1. Get the list of files with a .m extension in the current directory.
  functionfiles = dir('*.m')
2. Save the filenames in a cell array.
  functionfiles = {functionfiles.name};
3. Compile the Python package using compiler.build.pythonPackage.
  buildResults = compiler.build.pythonPackage(functionfiles,'PackageName','rectangleLib');
  For more details, see Generate Python Package and Build Python Application.

Write source code for a Python application that accesses the MATLAB functions.

The sample application for this example is rectangleDriver.py in the rectangle folder.

rectangleDriver.py

# Copyright 2019 The MathWorks, Inc.
import rectangleLib

def initializeLibrary():
    """ Initialize MATLAB rectangleLibrary library and retrieve a handle to it """
    handle = rectangleLib.initialize()
    return handle

class PyPoint:
    """Python class that uses a MATLAB class compiled with MATLAB Compiler SDK"""
    libHandle = 0

    @staticmethod
    def initializeHandle(handle):
        PyPoint.libHandle = handle

    # Initialize the point either from an existing Point (not PyPoint) object,
    # or from an X and Y pair.
    def __init__(self, pt=None, X=None, Y=None):
        if pt:
            if X or Y:
                raise ValueError('If pt is specified, neither X nor Y can be specified')
            else:
                self.data = pt
        else:
            if not X or not Y:
                raise ValueError('If pt is not specified, X and Y must be specified')
            else:
                self.data = PyPoint.libHandle.makePoint(X, Y)
    
    def getCoordinates(self):
        coordinates = PyPoint.libHandle.getPointCoordinates(self.data)
        return (coordinates['X'], coordinates['Y'])
        
class PyRectangle:
    """Python class that uses a MATLAB class compiled with MATLAB Compiler SDK"""

    # Class member that must be initialized before any PyRectangle object is instantiated
    libHandle = 0
    
    @staticmethod
    def initializeHandle(handle):
        PyRectangle.libHandle = handle
    
    # Initialize the point either from an existing Rectangle (not PyRectangle) object,
    # or from the coordinates of any two diagonally opposite corners.
    def __init__(self, rect=None, cornerAX=None, cornerAY=None, cornerBX=None, cornerBY=None):
        if rect:
            if cornerAX or cornerAY or cornerBX or cornerBY:
                raise ValueError(
                    'If rect is specified, no other keyword argument can be specified')
            else:
                self.data = rect
        else:
            if not cornerAX or not cornerAY or not cornerBX or not cornerBY:
                raise ValueError(
                    'If rect is not specified, the other keyword arguments must be specified')
            else:
                self.data = PyRectangle.libHandle.makeRectangle(
                    PyRectangle.libHandle.makePoint(cornerAX, cornerAY),
                    PyRectangle.libHandle.makePoint(cornerBX, cornerBY))

    def area(self):
        return PyRectangle.libHandle.getRectangleArea(self.data)
    
    def height(self):
        return PyRectangle.libHandle.getRectangleHeight(self.data)
        
    def width(self):
        return PyRectangle.libHandle.getRectangleWidth(self.data)
        
    def getCorners(self):
        return PyRectangle.libHandle.getRectangleCorners(self.data)
        
if __name__ == "__main__":

    libHandle = initializeLibrary()
    
    PyPoint.initializeHandle(libHandle)
    PyRectangle.initializeHandle(libHandle)
   
    print('Initializing module and creating a rectangle with corners (-1, 2) and (5, 10)...')
    rectA = PyRectangle(cornerAX=-1, cornerAY=2, cornerBX=5, cornerBY=10)
    print('Area: {0:.1f}'.format(rectA.area()))
    print('Height: {0:.1f}'.format(rectA.height()))
    print('Width: {0:.1f}'.format(rectA.width()))

    print('Corners:')
    corners = rectA.getCorners()
    for label in ('upperLeft', 'lowerLeft', 'upperRight', 'lowerRight'):
        pypoint = PyPoint(pt=corners[label])
        print('    {0}: {1}'.format(label, pypoint.getCoordinates()))

    print('')
    print('Executing rectangleDemo...')
    # nargout represents the number of output arguments. Its default value
    # is 1. rectangleDemo returns no output, so we need to explicitly set 
    # nargout to 0.
    libHandle.rectangleDemo(nargout=0)

The rectangleDriver application:

Defines two classes, PyPoint and PyRectangle
Creates a handle to the package using rectangleLib.initialize
Passes the package handle to the PyPoint and PyRectangle classes
Creates a PyRectangle object and prints its area, height, and width
Saves each corner as a PyPoint object and prints its coordinates
Calls the rectangleDemo MATLAB function to create and display data from a different rectangle

Open a system command prompt window and navigate to the rectangleLibpythonPackage folder that contains your generated package.
Install the package using the python command.
```
python -m pip install .
```
For more details, see Install and Import MATLAB Compiler SDK Python Packages.

Navigate up one directory and run the rectangleDriver.py application.

cd ..
python rectangleDriver.py

Initializing module and creating a rectangle with corners (-1, 2) and (5, 10)...
Area: 48.0
Height: 8.0
Width: 6.0
Corners:
    upperLeft: (-1.0, 2.0)
    lowerLeft: (-1.0, 10.0)
    upperRight: (5.0, 2.0)
    lowerRight: (5.0, 10.0)

Executing rectangleDemo...
Upper left-hand corner: (0.0, 0.0)
Lower left-hand corner: (0.0, 4.0)
Upper right-hand corner: (3.0, 0.0)
Lower right-hand corner: (3.0, 4.0)
Area: 12.0
Height: 4.0
Width: 3.0

Note

On macOS, you must use the mwpython script instead of python. For example, mwpython rectangleDriver.py.

The mwpython script is located in the matlabroot/bin folder, where matlabroot is the location of your MATLAB or MATLAB Runtime installation.