GroIMP wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Importing objects ======

With GroIMP it is possible to import objects from several 3d or graph formats into the project graph. The imported objects can then be used similarly to any other part of the graph.


In the following, a different way of adding a file will be shown based on {{ :tutorials:cherry_new.dtd | this}} dtd file. 


===== Using the Gui =====

==== Add directly ====

 {{:tutorials:import_menu.png?nolink&200 |}}
The easiest way is to add the object directly, using the main menu: Objects, there you can find the options insert File and insert File to RGG. 

They both work very similar, starting with a file dialog to choose which file to import and then turning this file into a graph and adding it. The only difference is that 'Insert File' adds the loaded graph to the root of the scene and 'Insert File to RGG' to the RGG root. This leads to the difference that a file inserted to RGG will be removed when the model is stopped or recompiled. 

In order to remove an object added to the root of the scene the function 'clear project graph' in the main menu: Edit can be used. Additionally it is always possible to select an object in the 2d or 3d view and use the delete key. 


In a new RGG project using the file from above the following result should be appearing:
{{:tutorials:import_dtd_res.png?nolink&500|}}

Since this little tree is added to the GroIMP Graph it can now be queried and manipulated using XL rules. 
For example to add the following query to the XL console should return 344. <code>count((*F*)); </code>

Or remove stepwise the last internodes:
<code>
	[f:F,(empty((*f --> Node*)))==>;]
</code>


==== Importing though RGG code ====

The same steps are also possible through RGG code. This allows us to automatize the loading of projects or to load at a certain step.

Importing through code gives us two options, adding directly to the root of the graph ( see above), or loading the file and return the node for further usage.

=== Import to the root ===

We can use the importNodeFromFile function with the path to the file as the first and the MimeType as the second parameter. 

<hidden finding MimeTypes for extension>

To find the MimeType for an extension, we can use the embedded documentation. For example to find the mimeType for a dtd file:

**1. Open the help**

by clicking in the main menu on Help > Help

**2. Enable "Diaplay all Plugins"**

To make sure you also search the auto generated documentation, add the checkbar to the option "Display all Plugins"

{{:tutorials:help_all_plugins.png?200|}}


**3. Search for the file extension**

Type the extension (in our case "dtd") with an additional dot up front: (e.g. ".dtd").

** 4. Find the file named "Import" **

{{:tutorials:find_import_help.png?200|}}


** 5. Find MimeType**

On this page you find a table with all import formats supported and their mimeTypes. 
The one you searched should be highlighted:

{{:tutorials:find_mimetype.png?400|}}


This should work for all supported format. If you cant find the format you are looking for it might be in a plugin that is not installed.
</hidden>


After downloading the dtd file we can use the code blow to import it by pressing the load button on the rgg toolbar.


<code java importNodeFromFile.rgg>

public void load(){
  //Maybe you have to change the path to fit your file system
  importNodeFromFile(getPathToHomeDirectory()+"\\Downloads\\cherry_new.dtd","model/x-grogra-dtd");
  }
</code>


The same function could also be used with an input stream. For example you can add the dtd file to the file explorer by using ''Object > New > Add File''. Make sure to choose "all files" as data type. After selecting the file choose add file. 

Afterwards the following code can be used to add the file directly from the GroIMP file system:

<code java importNodeFromStream.rgg>
public void load(){
  importNodeFromStream(getInputStreamFromProject("cherry_new.dtd"),"model/x-grogra-dtd");
}  
</code>


=== Import and return node ===

With the same parameters as above we can also use the loadNodeFromFile and loadeNodeFromStream functions. 
These functions return the root of the imported structure and therefore allow us to place it at any position in our graph. For example lats place the dtd tree twice in the graph once at 0,0,0 and once at 2,0,0. 

<code java loadNodeFromFile.rgg>
protected void init()[
 Axiom==>
  loadNodeFromFile(getPathToHomeDirectory()+"\\Downloads\\cherry_new.dtd","model/x-grogra-dtd") 
  [
   Translate(2,0,0) 
   loadNodeFromFile(getPathToHomeDirectory()+"\\Downloads\\cherry_new.dtd","model/x-grogra-dtd")
  ];
]

</code>


==== Using the Object explorer ====

A second more reusable way is to add the external objects to the Object explorer. The explorer can be found on the main menu on Panels/Explorers/Objects. In the newly opened panel a menu with the item Object should be visible. Under this item following the path '/new/insert File' we can select the same file as above. 
After selecting the file with the file dialog a popup asks "How should the file be added?" the three options mean:

__Add the file:__ the file is copied to a folder object in the GSZ or the project directory. This means the file is added to the project and will also be available if the project is moved.

__Link the file:__ only the path to the current file is added. This can be useful in a more complex pipeline where the external file is updated by another software or another GroIMP project. However, this relays on the file path to the external object. 

__Embed the file:__ The file is read and added to the meta graph. Doing so makes it independent from the format, the file or the import process. However, it is then part of the GroIMP graph and for bigger files this could slow down the simulation.

The choice really depends on the use case, but in our case the easiest is to add the file. 
After the file has been loaded it can be referenced from the RGG using 'Reference("cherry_new.dtd");'.
Using this in a XL query will create an instance of the imported object, in the Graph. This means it is not importing the graph structure but only one node representing the 3d structure.

For example the following code would create three times the same tree in a row:
<code>

protected void init ()
[
	Axiom ==> for(int i=0; i<3; i++)(
	Translate(0,1,0)
		[
			Reference("cherry_new.dtd")
		]
	);
]
</code>

It is also possible to access the graph structure of these referenced objects using the code below but it is more recommended to use the GraphExplorer to do so.
<code>
	{
	Reference ref = new Reference("cherry_new.dtd");
	Node refRoot = ref.resolveNode();
	}
</code>