Gsoc on Tushar Choudhary

Week 6 with GSoC

Mon, 08 Jul 2024 16:10:07 +0530

The sixth week was mainly focused on improving the code structure as well as implementation of the LayoutContext for fCoSE layout algorithm in the plugin.

TODOs

Generate a layout context for the fCoSE layout algorithm.
Implement TunableValidator for the layout context.
Get the parameters for the layout from the user using Tunable.
Dynamically generate the layout request using the parameters from the user.

Experiments with code

Implement TunableValidator for the layout context to validate the parameters for the layout.

package org.cytoscape.sample.internal;

import java.io.IOException;

import org.cytoscape.work.Tunable;
import org.cytoscape.work.TunableValidator;

public class CustomLayoutContext implements TunableValidator {

	@Tunable(description="Randomize")
	public boolean randomize = true; // Default value
	@Tunable(description="Node Dimensions Include Labels")
	public boolean nodeDimensionsIncludeLabels= true;// Default value
	@Tunable(description="Uniform Node Dimensions")
	public boolean uniformNodeDimensions= false;// Default value
	@Tunable(description="Pack Components")
	public boolean packComponents= true;// Default value
	@Tunable(description="Tile")
	public boolean tile= true;// Default value

	@Tunable(description="Padding")
	public int padding= 30;// Default value
	@Tunable(description="Node Repulsion")
	public int nodeRepulsion= 4500;// Default value
	@Tunable(description="Ideal Edge Length")
	public int idealEdgeLength= 50;// Default value
	@Tunable(description="Edge Elasticity")
	public double edgeElasticity= 0.45;// Default value
	@Tunable(description="Nesting Factor")
	public double nestingFactor= 0.1;// Default value
	@Tunable(description="Number of Iterations")
	public int numIter= 2500;// Default value
	@Tunable(description="Tiling Padding Vertical")
	public int tilingPaddingVertical= 10;// Default value
	@Tunable(description="Tiling Padding Horizontal")
	public int tilingPaddingHorizontal= 10;// Default value
	@Tunable(description="Gravity")
	public double gravity= 0.25;// Default value
	@Tunable(description="Gravity Range")
	public double gravityRange= 3.8;// Default value
	@Tunable(description="Gravity Compound")
	public double gravityCompound= 1;// Default value
	@Tunable(description="Gravity Range Compound")
	public double gravityRangeCompound= 1.5;// Default value
	@Tunable(description="Initial Energy On Incremental")
	public double initialEnergyOnIncremental= 0.3;// Default value


	public ValidationState getValidationState(final Appendable errMsg) {
		return ValidationState.OK;
	}
}

Learnings

The TunableValidator interface is used to validate the parameters for the layout.
The Tunable annotation is used to get the parameters from the user.
The LayoutContext is used to get and set the parameters for the layout from the user.
The layout context along with the tunable parameters generate a GUI for the user to input the parameters in a user friendly way.

Milestones

Successful implementation of the layout context for the fCoSE layout algorithm in the plugin to get the user entered parameters.

JSONObject layoutOptions = new JSONObject();
layoutOptions.put("name", "fcose");
layoutOptions.put("randomize", myContext.randomize);
layoutOptions.put("padding", myContext.padding);
layoutOptions.put("nodeDimensionsIncludeLabels", myContext.nodeDimensionsIncludeLabels);
layoutOptions.put("uniformNodeDimensions", myContext.uniformNodeDimensions);
layoutOptions.put("packComponents", myContext.packComponents);
layoutOptions.put("nodeRepulsion", myContext.nodeRepulsion);
layoutOptions.put("idealEdgeLength", myContext.idealEdgeLength);
layoutOptions.put("edgeElasticity", myContext.edgeElasticity);
layoutOptions.put("nestingFactor", myContext.nestingFactor);
layoutOptions.put("numIter", myContext.numIter);
layoutOptions.put("tile", myContext.tile);
layoutOptions.put("tilingPaddingVertical", myContext.tilingPaddingVertical);
layoutOptions.put("tilingPaddingHorizontal", myContext.tilingPaddingHorizontal);
layoutOptions.put("gravity", myContext.gravity);
layoutOptions.put("gravityRange", myContext.gravityRange);
layoutOptions.put("gravityCompound", myContext.gravityCompound);
layoutOptions.put("gravityRangeCompound", myContext.gravityRangeCompound);
layoutOptions.put("initialEnergyOnIncremental", myContext.initialEnergyOnIncremental);

Week 5 with GSoC

Mon, 01 Jul 2024 16:10:07 +0530

The fifth week was mainly focused on writing the functionalities as an implementation of the abstract layout algorithm laid down in cytoscape.

TODOs

Extend AbstractLayoutAlgorithm.
Implement fCoSE layout algorithm in the plugin.
Implement the task iterator to apply the layout changes to the network in cytoscape.
Implement doLayout method to apply the layout changes to the network in cytoscape.

Experiments with code

Extended the AbstractLayoutAlgorithm class to implement the fCoSE layout algorithm. Using the previously developed knowledge and code, the migration to extend the abstract class was smooth.

public class CustomLayout extends AbstractLayoutAlgorithm {
	/**
	 * Creates a new MyLayout object.
	 */
	private final CyNetworkViewWriterFactory writeCyJs;

	public CustomLayout(UndoSupport undo, CyNetworkViewWriterFactory writeNetwork) {
		super("customLayout","Custom Layout", undo);
		this.writeCyJs = writeNetwork;
	}

	public TaskIterator createTaskIterator(CyNetworkView networkView,
 Object context,
 Set<View<CyNode>> nodesToLayOut,
 String attrName) {
		final CyNetworkView myView = networkView;
		final CyNetworkViewWriterFactory writeCyJs = this.writeCyJs;
		Task task = new AbstractLayoutTask(toString(), networkView, nodesToLayOut, attrName, undoSupport) {
 @Override
			protected void doLayout(TaskMonitor taskMonitor) {
 //.....
				}		
			}
		};
		return new TaskIterator(task);
	}
}

Learnings

The AbstractLayoutAlgorithm class provides a lot of functionalities that can be used to implement the layout algorithms in cytoscape.
The createTaskIterator method is used to create a task iterator which is used to apply the layout changes to the network in cytoscape.
The doLayout method is used to apply the layout changes to the network in cytoscape.
Cytoscape layouts also offer layout context which can be used to get and set the parameters for the layout from the user.

Milestones

Successful implementation of fCoSE layout algorithm in the plugin.

Week 4 with GSoC

Mon, 24 Jun 2024 16:10:07 +0530

The fourth week included a lot of coding and debugging. The main goal was to successfully apply the layout changes to the network in cytoscape using the response from SyBLaRS API.

TODOs

Parse the response from SyBLaRS API to get the layout changes.
Format the response from the SyBLaRS API to extract the layout changes.
Fetch the node information from the network in cytoscape.
Apply the layout changes to the network in cytoscape.

Experiments with code

Tried to use org.json library to parse the JSON resonse and extract the required details from the response.
- Using this library with the below given version caused cytoscape to stop detecting my plugin which prompted me to use javax.json package.
- Eventually with the help of my mentor we figured out the issue, which was a mismatch between versions of the org.json library used in the plugin and the one used in the cytoscape application.

// Parse the JSON string
JSONObject json = new JSONObject(dataToSend);

// Access the value of a specific key
String elements = json.getJSONObject("elements").toString();

dataToSend = elements;

<!-- Incorrect version -->
<dependency>
 <groupId>org.json</groupId>
 <artifactId>json</artifactId>
 <version>20210307</version>
</dependency>

<!-- Correct version -->
<dependency>
 <groupId>org.json</groupId>
 <artifactId>org.json</artifactId>
 <version>chargebee-1.0</version>
</dependency>

Learnings

The Cytoscape desktop application uses multiple external dependencies which might conflict with the dependencies used in the plugin.
The Cytoscape desktop application maintains a descriptive error log which is very helpful in debugging the issues.
SybLaRS expects only the "elements" object of the exported network JSON to be sent as the request body.

Milestones

Successful parsing of the response from SyBLaRS API

Parse the JSON response from the SyBLaRS API to extract the layout changes and the node information.
Store the new coordinates of the nodes in a map with the node id as the key.

//iterate over response
JSONObject jsonResponse = new JSONObject(response.toString());
JSONObject layoutFromResponse = jsonResponse.getJSONObject("layout");
Iterator<String> nodes = layoutFromResponse.keys();
while(nodes.hasNext()) {
 String node = nodes.next();
 JSONObject value = layoutFromResponse.getJSONObject(node);
 JSONObject position = value.getJSONObject("position");
 try {
 nodePositions.put(node, position);
 } catch (Exception e) {
 System.out.println("Exception: " + e.getMessage());
 }

Successful application of layout changes to the network in Cytoscape

Set the node positions by matching the nodes with SUID.

// Set the node positions
final VisualProperty<Double> xLoc = BasicVisualLexicon.NODE_X_LOCATION;
final VisualProperty<Double> yLoc = BasicVisualLexicon.NODE_Y_LOCATION;

for(View<CyNode> nodeView : myView.getNodeViews()) {
 String nodeName = myView.getModel().getRow(nodeView.getModel()).get("name", String.class);
 String nodeId = nodeView.getModel().getSUID().toString();
 JSONObject position = nodePositions.get(nodeId);
 if(position != null) {
 nodeView.setVisualProperty(xLoc, position.getDouble("x"));
 nodeView.setVisualProperty(yLoc, position.getDouble("y"));
 }
}

Week 3 with GSoC

Mon, 17 Jun 2024 16:10:07 +0530

The third week included a lot of exploration and trying out multiple approaches to successfully connect cytoscape plugin to the SyBLaRS API.

TODOs

Run SyBLaRS API locally.
Figure out how to make HTTP API requests from cytoscape plugin.
Figure out how to make custom HTTP API requests to SyBLaRS with static reuqest body.
Figure out how to make custom HTTP API requests to SyBLaRS with dynamic request body fetched from the current network in cytoscape.

Experiments with code

Tried to use okHTTP to make HTTP requests from the plugin. Cytoscape fails to detect the plugin when okHTTP was used to make HTTP requests. Below is the code used.

//API Call
String url = "http://localhost:3000/json?image=false";
String dataToSend = outputString.toString();
String optionsString = "{\"layoutOptions\":{\"name\":\"fcose\",\"randomize\":true,\"padding\":30,\"nodeDimensionsIncludeLabels\":true,\"uniformNodeDimensions\":false,\"packComponents\":true,\"nodeRepulsion\":4500,\"idealEdgeLength\":50,\"edgeElasticity\":0.45,\"nestingFactor\":0.1,\"numIter\":2500,\"tile\":true,\"tilingPaddingVertical\":10,\"tilingPaddingHorizontal\":10,\"gravity\":0.25,\"gravityRange\":3.8,\"gravityCompound\":1,\"gravityRangeCompound\":1.5,\"initialEnergyOnIncremental\":0.3},\"imageOptions\":{\"format\":\"png\",\"background\":\"transparent\",\"width\":1280,\"height\":720,\"color\":\"bluescale\"}}";
// Define the request body
String payload = dataToSend + optionsString;
System.out.println("$$Payload: " + payload);

// Create the request body object
RequestBody body = RequestBody.create(
 payload, MediaType.parse("text/plain")
);

// Create the request object
Request request = new Request.Builder()
 .url("http://localhost:3000/json?image=false")
 .post(body)
 .addHeader("Accept", "application/json")
 .addHeader("Content-Type", "text/plain")
 .build();

// Create the OkHttp client
OkHttpClient client = new OkHttpClient();

// Execute the request
client.newCall(request).enqueue(new Callback() {
 @Override
 public void onFailure(Call call, IOException e) {
 e.printStackTrace();
 }

 @Override
 public void onResponse(Call call, Response response) throws IOException {
 if (!response.isSuccessful()) {
 throw new IOException("Unexpected code " + response);
 }

 // Handle the response
 String responseBody = response.body().string();
 System.out.println(responseBody);
 }
});

<dependency>
 <groupId>com.squareup.okhttp3</groupId>
 <artifactId>okhttp</artifactId>
 <version>4.9.1</version> <!-- Use the latest version -->
 <scope>provided</scope>
</dependency>

Tried to use the Java.net package to make HTTP requests from the plugin. Cytoscape was able to detect the plugin when Java.net package was used to make HTTP requests. Below is the code used.

String url = "http://localhost:3000/json?image=false";
String dataToSend = outputString.toString();
String optionsString = "{\"layoutOptions\":{\"name\":\"fcose\",\"randomize\":true,\"padding\":30,\"nodeDimensionsIncludeLabels\":true,\"uniformNodeDimensions\":false,\"packComponents\":true,\"nodeRepulsion\":4500,\"idealEdgeLength\":50,\"edgeElasticity\":0.45,\"nestingFactor\":0.1,\"numIter\":2500,\"tile\":true,\"tilingPaddingVertical\":10,\"tilingPaddingHorizontal\":10,\"gravity\":0.25,\"gravityRange\":3.8,\"gravityCompound\":1,\"gravityRangeCompound\":1.5,\"initialEnergyOnIncremental\":0.3},\"imageOptions\":{\"format\":\"png\",\"background\":\"transparent\",\"width\":1280,\"height\":720,\"color\":\"bluescale\"}}";

String payload = "[" + dataToSend + "," + optionsString + "]";

System.out.println("Payload: " + payload);

try {
 URL obj = new URI(url).toURL();
 HttpURLConnection connection = (HttpURLConnection) obj.openConnection();
 connection.setRequestMethod("POST");
 connection.setRequestProperty("Content-Type", "text/plain");
 connection.setDoOutput(true);
 try (DataOutputStream os = new DataOutputStream(connection.getOutputStream())) {
 os.writeBytes(payload);
 os.flush();
 }
 int responseCode = connection.getResponseCode();
 if(responseCode == HttpURLConnection.HTTP_OK) {
 StringBuilder response = new StringBuilder();
 try (
 BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()))
 ) {
 String line;
 while((line = reader.readLine()) != null) {
 response.append(line);
 }
 }
 System.out.println("Response: " + response.toString());
 }
 else {
 System.out.println("POST request failed: " + responseCode);
 }
 connection.disconnect();
}
catch (Exception e) {
 System.out.println("Exception: " + e.getMessage());
 e.printStackTrace();
}

Learnings

The Cytoscape desktop application cannot detect plugins with okHTTP as dependency which may have some caveat that i may be overlooking.
SybLarS expects a JSON array as the request body which contains the data and the options for the layout when posting data to “/json” endpoint.

Milestones

Successful HTTP requests to SyBLaRS API

Figured out how to trigger the API request to SyBLaRS from the plugin.

Week 2 with GSoC

Mon, 10 Jun 2024 16:10:07 +0530

The second week included a lot more application of the information gathered in the first week. I also experimented with the pre populated layouts on Cytoscape desktop application.

TODOs

Figure out how to add multiple entries in the application menu from a single plugin.
Figure out the Cytoscape.js JSON export handler in the cytoscape desktop application.
Find out a way to trigger the export from the plugin.
Figure out how to populate the layout settings menu with the new layouts from cytoscape.js.

Experiments with code

Tried to populate a submenu in the layout menu with multiple entries which will ultimately be used to populate the layouts from the cytoscape.js layouts. To do this i had to register multiple services from a single application.

Properties createNetworkViewTaskFactoryProps = new Properties();
createNetworkViewTaskFactoryProps.setProperty("preferredMenu","Layout.CytoJS Layouts");
createNetworkViewTaskFactoryProps.setProperty("title","Layout 1");
registerService(bc,createNetworkViewTaskFactory,TaskFactory.class, createNetworkViewTaskFactoryProps);

Properties createNetworkViewTaskFactoryProps1 = new Properties();
createNetworkViewTaskFactoryProps1.setProperty("preferredMenu","Layout.CytoJS Layouts");
createNetworkViewTaskFactoryProps1.setProperty("title","Layout 2");
registerService(bc,createNetworkViewTaskFactory,TaskFactory.class, createNetworkViewTaskFactoryProps1);

Learnings

The Cytoscape desktop application uses a plugin named JSON which is included as a core plugin. Thanks to my mentor¹ for pointing me to the right direction.
Upon investigating the code and a little help from Cytoscape app developers’ google group² i was able to figure out how to use the CytoscapeJS JSON export service in my plugin.

Milestones

Automation of JSON export

Figured out how to trigger the JSON export from the plugin.

Week 1 with GSoC

Mon, 03 Jun 2024 16:10:07 +0530

The first week was fairly informative. Following is a list of my learnings this week:

Learned quite a lot about how the Cytoscape apps work and how they are written.
Running cytoscape in debug mode and listening to the debug port from intellij by setting up debug configurations.
OSGi model and how cytoscape uses it to structure the software.
How to write OSGi configurations.
How to add the instance of the cytoscape app in the menu bar of cytoscape.
How nodes and networks are modeled in cytoscape.
Following things related to Nodes in networks
- Creating nodes
- Naming the nodes
- Creating edges
- Node table entries
Following things related to cytoscape apps
- Tasks
- Task factories
- Network views
- Network managers

Further i plan to take a look at how cytoscape exports networks in the form of cytoscape.js json file.