anchor.diff:  
   *3. Java Layout as 1D Pixel Array*
   
  -The most common approach for getting image data is to copy the backing array of Java's `BufferedImage` class and to reshape the memory using MATLAB (compare this link:https://mathworks.com/matlabcentral/answers/100155-how-can-i-convert-a-java-image-object-into-a-matlab-image-matrix#answer_109503[answer]).
  +The likely most common approach (and the accepted link:https://mathworks.com/matlabcentral/answers/100155-how-can-i-convert-a-java-image-object-into-a-matlab-image-matrix#answer_109503[answer] for converting Java images to MATLAB matrices) is to copy the pixel array of Java's `BufferedImage` and to reshape the memory using MATLAB routines.
   
   [source,matlab]
   ----
  
positive.code: 
  The biggest takeaway for us was that MATLAB supports shared memory. We had used shared memory before for inter-process communication in Java and C++, but we somehow assumed that MATLAB wouldn't support it. We eventually looked into this and found that MATLAB does have support, and that the implementation is actually quite nice. The data definition can even map the memory to an array of structs with multiple variables.
  
  Using shared memory allows us to bypass the Java translation layer entirely and to even include meta data such as timestamps or frame sequence numbers. However, for us the most interesting application is still its use for inter process communication. For example, we can have two MATLAB instances exchange almost arbitrary aounts of data by simply defining a common shared struct.
  
  This enables us to run one instance that tracks a target at a low rate (e.g. 30 Hz), and another instance for calculating and executing trajectories at a higher rate (e.g. >100 Hz), without needing to setup an inter-process communication framework like LCM, or the need to define any marshalling or custom binary formats.
  
  We will publish more details about inter-process communication as well as synchronization between multiple instances in a future blog post.
  
  // Using Java's `Unsafe` we can even implement synchronization mechanisms in shared memory that enable safe inter process communication. This means that we can exchange large amounts of data between MATLAB instances extremely efficiently, without the need for any complex frameworks. The data format can be changed at runtime, without worrying about recompiling and generating message definitions.
  
  
negative.code: 
  *5. MATLAB Layout as Shared Memory*
  
  This approach is the same as 4. with the difference being that the data is exchanged through shared memory using link:https://mathworks.com/help/matlab/ref/memmapfile.html[memmapfile], thus bypassing the Java translation layer entirely. Shared memory is typically used for inter-process communication, but it can also be used within a single process. Running it in the same process also simplifies synchronization since we can use standard Java locks.
  
  [source,matlab]
  ----
  