formatted_io5 Example

Python Version

Model Code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import pprint
# Import classes for input/output channels
from cis_interface.interface.CisInterface import (
    CisPlyInput, CisPlyOutput)

# Initialize input/output channels
in_channel = CisPlyInput('inputA')
out_channel = CisPlyOutput('outputA')

# Loop until there is no longer input or the queues are closed
while True:

    # Receive input from input channel
    # If there is an error, the flag will be False
    flag, ply = in_channel.recv()
    if not flag:
        print("Model A: No more input.")
        break

    # Print received message
    print('Model A: (%d verts, %d faces)' % (ply.nvert, ply.nface))
    pprint.pprint(ply)

    # Send output to output channel
    # If there is an error, the flag will be False
    flag = out_channel.send(ply)
    if not flag:
        raise RuntimeError("Model A: Error sending output.")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import pprint
# Import classes for input/output channels
from cis_interface.interface.CisInterface import (
    CisPlyInput, CisPlyOutput)

# Initialize input/output channels
in_channel = CisPlyInput('inputB')
out_channel = CisPlyOutput('outputB')

# Loop until there is no longer input or the queues are closed
while True:

    # Receive input from input channel
    # If there is an error, the flag will be False
    flag, ply = in_channel.recv()
    if not flag:
        print("Model B: No more input.")
        break

    # Print received message
    print('Model B: (%d verts, %d faces)' % (ply.nvert, ply.nface))
    pprint.pprint(ply)

    # Send output to output channel
    # If there is an error, the flag will be False
    flag = out_channel.send(ply)
    if not flag:
        raise RuntimeError("Model B: Error sending output.")

Model YAML:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
models:
  - name: python_modelA
    language: python
    args: ./src/formatted_io5_modelA.py
    inputs: inputA
    outputs: outputA

  - name: python_modelB
    language: python
    args: ./src/formatted_io5_modelB.py
    inputs: inputB
    outputs: outputB

connections:
  - input: outputA  # Connection between model A output & model B input
    output: inputB
  - input: ./Input/input.ply  # Connection between file and model A input
    output: inputA
    filetype: ply
  - input: outputB  # Connection between model B output and file
    output: ./output.ply
    filetype: ply

Matlab Version

Model Code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
% Initialize input/output channels 
in_channel = CisInterface('CisPlyInput', 'inputA');
out_channel = CisInterface('CisPlyOutput', 'outputA');

flag = true;

% Loop until there is no longer input or the queues are closed
while flag

  % Receive input from input channel
  % If there is an error, the flag will be False.
  [flag, ply] = in_channel.recv();
  if (~flag)
    disp('Model A: No more input.');
    break;
  end;

  % Print received message
  fprintf('Model A: (%d verts, %d faces)\n', ...
          length(ply('vertices')), length(ply('faces')));
  disp(ply);

  % Send output to output channel
  % If there is an error, the flag will be False
  flag = out_channel.send(ply);
  if (~flag)
    error('Model A: Error sending output.');
    break;
  end;
  
end;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
% Initialize input/output channels 
in_channel = CisInterface('CisPlyInput', 'inputB');
out_channel = CisInterface('CisPlyOutput', 'outputB');

flag = true;

% Loop until there is no longer input or the queues are closed
while flag

  % Receive input from input channel
  % If there is an error, the flag will be False.
  [flag, ply] = in_channel.recv();
  if (~flag)
    disp('Model B: No more input.');
    break;
  end;

  % Print received message
  fprintf('Model B: (%d verts, %d faces)\n', ...
          length(ply('vertices')), length(ply('faces')));
  disp(ply);

  % Send output to output channel
  % If there is an error, the flag will be False
  flag = out_channel.send(ply);
  if (~flag)
    error('Model B: Error sending output.');
    break;
  end;
  
end;

Model YAML:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
models:
  - name: matlab_modelA
    language: matlab
    args: ./src/formatted_io5_modelA.m
    inputs: inputA
    outputs: outputA

  - name: matlab_modelB
    language: matlab
    args: ./src/formatted_io5_modelB.m
    inputs: inputB
    outputs: outputB

connections:
  - input: outputA  # Connection between model A output & model B input
    output: inputB
  - input: ./Input/input.ply  # Connection between file and model A input
    output: inputA
    filetype: ply
  - input: outputB  # Connection between model B output and file
    output: ./output.ply
    filetype: ply

C Version

Model Code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <stdio.h>
// Include methods for input/output channels
#include "CisInterface.h"

int main(int argc, char *argv[]) {
  // Initialize input/output channels
  cisPlyInput_t in_channel = cisPlyInput("inputA");
  cisPlyOutput_t out_channel = cisPlyOutput("outputA");

  // Declare resulting variables and create buffer for received message
  int flag = 1;
  ply_t p = init_ply();

  // Loop until there is no longer input or the queues are closed
  while (flag >= 0) {
  
    // Receive input from input channel
    // If there is an error, the flag will be negative
    // Otherwise, it is the size of the received message
    flag = cisRecv(in_channel, &p);
    if (flag < 0) {
      printf("Model A: No more input.\n");
      break;
    }

    // Print received message
    printf("Model A: (%d verts, %d faces)\n", p.nvert, p.nface);
    int i, j;
    printf("  Vertices:\n");
    for (i = 0; i < p.nvert; i++) {
      printf("   %f, %f, %f\n",
	     p.vertices[i][0], p.vertices[i][1], p.vertices[i][2]);
    }
    printf("  Faces:\n");
    for (i = 0; i < p.nface; i++) {
      printf("   %d", p.faces[i][0]);
      for (j = 1; j < p.nvert_in_face[i]; j++)
	printf(", %d", p.faces[i][j]);
      printf("\n");
    }

    // Send output to output channel
    // If there is an error, the flag will be negative
    flag = cisSend(out_channel, p);
    if (flag < 0) {
      printf("Model A: Error sending output.\n");
      break;
    }

  }

  // Free dynamically allocated ply structure
  free_ply(&p);
  
  return 0;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <stdio.h>
// Include methods for input/output channels
#include "CisInterface.h"

int main(int argc, char *argv[]) {
  // Initialize input/output channels
  cisPlyInput_t in_channel = cisPlyInput("inputB");
  cisPlyOutput_t out_channel = cisPlyOutput("outputB");

  // Declare resulting variables and create buffer for received message
  int flag = 1;
  ply_t p = init_ply();

  // Loop until there is no longer input or the queues are closed
  while (flag >= 0) {
  
    // Receive input from input channel
    // If there is an error, the flag will be negative
    // Otherwise, it is the size of the received message
    flag = cisRecv(in_channel, &p);
    if (flag < 0) {
      printf("Model B: No more input.\n");
      break;
    }

    // Print received message
    printf("Model B: (%d verts, %d faces)\n", p.nvert, p.nface);
    int i, j;
    printf("  Vertices:\n");
    for (i = 0; i < p.nvert; i++) {
      printf("   %f, %f, %f\n",
	     p.vertices[i][0], p.vertices[i][1], p.vertices[i][2]);
    }
    printf("  Faces:\n");
    for (i = 0; i < p.nface; i++) {
      printf("   %d", p.faces[i][0]);
      for (j = 1; j < p.nvert_in_face[i]; j++)
	printf(", %d", p.faces[i][j]);
      printf("\n");
    }

    // Send output to output channel
    // If there is an error, the flag will be negative
    flag = cisSend(out_channel, p);
    if (flag < 0) {
      printf("Model B: Error sending output.\n");
      break;
    }

  }
  
  // Free dynamically allocated ply structure
  free_ply(&p);
  
  return 0;
}

Model YAML:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
models:
  - name: c_modelA
    language: c
    args: ./src/formatted_io5_modelA.c
    inputs: inputA
    outputs: outputA

  - name: c_modelB
    language: c
    args: ./src/formatted_io5_modelB.c
    inputs: inputB
    outputs: outputB

connections:
  - input: outputA  # Connection between model A output & model B input
    output: inputB
  - input: ./Input/input.ply  # Connection between file and model A input
    output: inputA
    filetype: ply
  - input: outputB  # Connection between model B output and file
    output: ./output.ply
    filetype: ply

C++ Version

Model Code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#include <iostream>
// Include methods for input/output channels
#include "CisInterface.hpp"

int main(int argc, char *argv[]) {
  // Initialize input/output channels
  CisPlyInput in_channel("inputA");
  CisPlyOutput out_channel("outputA");

  // Declare resulting variables and create buffer for received message
  int flag = 1;
  ply_t p = init_ply();

  // Loop until there is no longer input or the queues are closed
  while (flag >= 0) {
  
    // Receive input from input channel
    // If there is an error, the flag will be negative
    // Otherwise, it is the size of the received message
    flag = in_channel.recv(1, &p);
    if (flag < 0) {
      std::cout << "Model A: No more input." << std::endl;
      break;
    }

    // Print received message
    printf("Model A: (%d verts, %d faces)\n", p.nvert, p.nface);
    int i, j;
    printf("  Vertices:\n");
    for (i = 0; i < p.nvert; i++) {
      printf("   %f, %f, %f\n",
	     p.vertices[i][0], p.vertices[i][1], p.vertices[i][2]);
    }
    printf("  Faces:\n");
    for (i = 0; i < p.nface; i++) {
      printf("   %d", p.faces[i][0]);
      for (j = 1; j < p.nvert_in_face[i]; j++)
	printf(", %d", p.faces[i][j]);
      printf("\n");
    }

    // Send output to output channel
    // If there is an error, the flag will be negative
    flag = out_channel.send(1, p);
    if (flag < 0) {
      std::cout << "Model A: Error sending output." << std::endl;
      break;
    }

  }
  
  // Free dynamically allocated structure
  free_ply(&p);
  
  return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <iostream>
// Include methods for input/output channels
#include "CisInterface.hpp"

#define MYBUFSIZ 1000

int main(int argc, char *argv[]) {
  // Initialize input/output channels
  CisPlyInput in_channel("inputB");
  CisPlyOutput out_channel("outputB");

  // Declare resulting variables and create buffer for received message
  int flag = 1;
  ply_t p = init_ply();

  // Loop until there is no longer input or the queues are closed
  while (flag >= 0) {
  
    // Receive input from input channel
    // If there is an error, the flag will be negative
    // Otherwise, it is the size of the received message
    flag = in_channel.recv(1, &p);
    if (flag < 0) {
      std::cout << "Model B: No more input." << std::endl;
      break;
    }

    // Print received message
    printf("Model B: (%d verts, %d faces)\n", p.nvert, p.nface);
    int i, j;
    printf("  Vertices:\n");
    for (i = 0; i < p.nvert; i++) {
      printf("   %f, %f, %f\n",
	     p.vertices[i][0], p.vertices[i][1], p.vertices[i][2]);
    }
    printf("  Faces:\n");
    for (i = 0; i < p.nface; i++) {
      printf("   %d", p.faces[i][0]);
      for (j = 1; j < p.nvert_in_face[i]; j++)
	printf(", %d", p.faces[i][j]);
      printf("\n");
    }

    // Send output to output channel
    // If there is an error, the flag will be negative
    flag = out_channel.send(1, p);
    if (flag < 0) {
      std::cout << "Model B: Error sending output." << std::endl;
      break;
    }

  }
  
  // Free dynamically allocated structure
  free_ply(&p);
  
  return 0;
}

Model YAML:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
models:
  - name: cpp_modelA
    language: c++
    args: ./src/formatted_io5_modelA.cpp
    inputs: inputA
    outputs: outputA

  - name: cpp_modelB
    language: c++
    args: ./src/formatted_io5_modelB.cpp
    inputs: inputB
    outputs: outputB

connections:
  - input: outputA  # Connection between model A output & model B input
    output: inputB
  - input: ./Input/input.ply  # Connection between file and model A input
    output: inputA
    filetype: ply
  - input: outputB  # Connection between model B output and file
    output: ./output.ply
    filetype: ply