Matrix as first class citizen in Processing.R

[gaocegege]

Now the parameters in Processing functions are float, int or string. R has a awesome built-in data structure called matrix, if we could call Processing functions with matrix as parameters, it will be cool.

[jeremydouglass]

This looks a bit tricky.

If I am understanding right, in Renjin you have to detect a that a Vector / AtomicVector is a matrix through AttribMap.getDim() -- or through a wrapper class Matrix.

• 3.4.1.6. Matrices and arrays
• 3.4.3.2. Dealing with matrices
• Source: renjin/primitives/matrix/

So a Java signature would have several cases of different matrix argument lengths embedded in it, and might look something like...? (untested):

public void rect(Vector v) {
  try {
    Matrix m = new Matrix(v);
  } catch(IllegalArgumentException e) {
    System.out.println("Result is not a matrix: " + e);
  }
  switch(m.length()) {
    case 4:
      super.rect(
        (float)m.getElementAsDouble(0), (float)m.getElementAsDouble(1),
        (float)m.getElementAsDouble(2), (float)m.getElementAsDouble(3)
      );
      break;
    case 8: // rounded corners
      super.rect(
        (float)m.getElementAsDouble(0), (float)m.getElementAsDouble(1),
        (float)m.getElementAsDouble(2), (float)m.getElementAsDouble(3),
        (float)m.getElementAsDouble(4), (float)m.getElementAsDouble(5),
        (float)m.getElementAsDouble(6), (float)m.getElementAsDouble(7)
      );
    default:
      throw new IllegalArgumentException("Wrong argument length:" + m.length());
  }
}

Or you could skip the Matrix try-catch block, and just accept any vector. This would work for both matrices and non-matrices.

[jeremydouglass]

Some good tests for mapping R matrix arguments to Processing API functions would be functions with longer argument counts and multiple signatures. For example:

• https://processing.org/reference/line_.html
• https://processing.org/reference/rect_.html
• https://processing.org/reference/quad_.html
• https://processing.org/reference/bezier_.html
• https://processing.org/reference/curve_.html

[jeremydouglass]

A related concept might be allowing class PVector to take an R Matrix/Vector of length 2 or 3 as a constructor argument.

[jeremydouglass]

An even more extended concept: convenience wrappers for the vertex functions.

• https://processing.org/reference/vertex_.html
• https://processing.org/reference/bezierVertex_.html
• https://processing.org/reference/quadraticVertex_.html

This would be going beyond the Processing core API, in that an R call

vertex(Matrix m)

would result in multiple vertex calls in Java:

vertex(float a, float b);
vertex(float c, float d);
vertex(float e, float f);

Something like this (untested):

// call super.vertex for each row in matrix
public void vertex(Vector v) {
  try {
    Matrix m = new Matrix(v);
  } catch(IllegalArgumentException e) {
    System.out.println("Result is not a matrix: " + e);
  }
  int rows=m.getNumRows();
  int cols=m.getNumCols();
  for(int i=0;i<rows;i++){
    switch(cols) {
    case 2:
      super.vertex((float)m.getElementAsDouble(i*cols), (float)m.getElementAsDouble((i+1)*cols));
      break;
    default:
      throw new IllegalArgumentException("Wrong argument length:" + m.length());
  }
}

Note that vertex() already accepts its arguments as a float[] v. The simplest form inside the loop would be to pass the matrix row as a float[]. However this is not true of bezierVertex and quadraticVertex.

[gaocegege]

> matrix1
x1 y1 x2 y2
1 2 3 4
> line(matrix1, x1 = x1, y1 = y1, x2 = x2, y2 = y2)
> line(x1 = matrix1$x1, y1 = matrix$y1, x2 = matrix$x2, y2 = matrix$y2)

I think the way is generally accepted by R users.

[jeremydouglass]

Interesting! Given a matrix:

(matrix2 <- matrix(
  1:16,
  ncol = 4,
  dimnames = list(
    c("A", "B", "C", "D"),
    c("x0", "y0", "x1", "y1")
  )
))

#    x0  y0  x1  y1
# A   1   2   3   4
# B   5   6   7   8
# C   9  10  11  12
# D  13  14  15  16

for(i in 1:nrow(matrix2)) {
  print(matrix2[,i])
}

# this prints four vectors:
# c(1L, 2L, 3L, 4L)c(5L, 6L, 7L, 8L)c(9L, 10L, 11L, 12L)c(13L, 14L, 15L, 16L)

Edit: The matrix can already be drawn in Processing.R as a series of lines like this:

for(i in 1:nrow(a_matrix)) {
  line(a_matrix[1,i], a_matrix[2,i], a_matrix[3,i], a_matrix[4,i])
}

...what about using a matrix like that and calling line with a vector argument, something like this:

for(i in 1:nrow(matrix2)) {
  line(matrix2[,i])
}

Here line() might take a vector as an argument -- the vector has 4 values (or maybe 6 in P3D). That makes it easy to loop through a matrix (or any subset of a larger matrix) and produce arguments.

What do you think?

Or should the inner loop only be arguments like Rs segments?

line(matrix1, x1 = x1, y1 = y1, x2 = x2, y2 = y2)
line(x1 = matrix1$x1, y1 = matrix$y1, x2 = matrix$x2, y2 = matrix$y2)

[gaocegege]

I think the way line(matrix2[,i]) is not as flexible as line(matrix1, x1 = x1, y1 = y1, x2 = x2, y2 = y2). Actually I think maybe line(x1, y1, x2, y2) is better, x1,y1,x2,y2 are all vectors.

[jeremydouglass]

I think maybe line(x1, y1, x2, y2) is better, x1,y1,x2,y2 are all vectors.

So, something like this example from above?

for(i in 1:nrow(a_matrix)) {
  line(a_matrix[1,i], a_matrix[2,i], a_matrix[3,i], a_matrix[4,i])
}

I'm trying to figure out what the syntax will look like when it line is being used on with actual matrix (more than one row).

[gaocegege]

No, I mean

line(a_matrix[1,], a_matrix[2,], a_matrix[3,], a_matrix[4,])