Simple C# example


#1

Hi guys,
hope you are doing well there in London!
I am developing some C# code atm and want to send some data to https://hestia.speckle.works.
I have an account, a JWT token and I managed to add SpeckleCore to my dependencies.
Now I am struggling a bit to get started and looking into SpeckleRhino as an example seems a bit over the top.

So, is there some simple boilerplate example in C# of how to login, send, receive, etc. some data?
Or maybe you have any other hints on how to get started with SpeckleCore? :wink:

Cheers
Til


#2

Guten morgen Tilman, nice to see you around these parts :slight_smile:

We don’t really have too much docs on those parts unfortunately. It would be great to populate this page after we’re through with this thread!

It would help to understand what data you want to send first, and I can cook up an example!

Warm regards,
Dimitrie


#3

Yeah, I am pretty happy to be finally able to do some coding, especially with Speckle :wink:

So my data looks something like this atm:

public class Node { public int id; public float x; public float y; public float z; } public class Quad { public int id; public Node[] nodes; public int group; public float vx; public float vy; public float nx; public float ny; public float nxy; public float sigx; public float sigy; public float tau; public int iteration; }

My object model is probably gonna change this afternoon already, but it´s basically a finite element mesh with nodes and shell elements and some results attached to it.

edit: sorry, I don´t know where the line breaks went…


#4

Okay, backtracking a bit, you do know there’s a bunch of Arup structural classes here that you can create with the schema builder components here, that do support quads afaik, and then you can also spin them online and colour them by their results.

Here’s an example from @mishaelnuh of a model coming out of gsa.

That aside, those look fine, and they’ll probably pass natively as abstract objects. I’ll try and hack an example after lunch, or now. There’s two approaches:

  • if you’re creating those objects in a c# script in grasshopper, you can probably just plop them into a sender, and it should work.

  • if you want to send data from your c# script (is it in grasshopper?) i’ll write down a minimal example!


#5

I am reading results from Sofistik and thus I created a console application in Visual Studio.
The idea is to do some post-processing with the data and then feeding them back into the next iteration in Sofistik.
That´s why I want to stick close to Sofistik´s data model. But I´ll try to use some existing classes!


#6

Gotcha. I’ll still write that example up!


#7

Okay, here you go: https://github.com/didimitrie/SpkConsole

Wasn’t that a big hassle. Abstract conversion is really slow, but you get the gist. It should describe the main motions you need to go though!


#8

Okay, i’ve actually just made some improvements to that. It’s neater now :slight_smile:

What it shows:

  • how to retrieve accounts from the end-users’s computer, using the LocalContext.GetAccountsByEmail() function
  • how to create a stream
  • how to get a stream (the same one created previously)
  • how a mini speckle-native object model can be created (check the Models.cs file).

Hopefully, even if this comes late, will be useful to more.


#9

Great!
And it works :slight_smile:
I had to change the server adress in GetStream() to
https://hestia.speckle.works/api/v1
though.
More feedback later.


#10

So, it works for my a little example with around 100 nodes and quads.
In my production case I have about 70000 nodes and quads though… :wink:
… and get an exception after 2 seconds: One or more errors occurred.


#11

It’s not a problem: you need to orchestrate the requests by saving objects separately first and then referencing them in the stream. I’ll write an example later.

Nevertheless, there’s a prior question then: saving 70k nodes individually is not the most effective way of dealing with this - are you going to need them separately? This sounds much more approachable as a 70k vertex mesh with quads (or 7 * 10k verts meshes), and some separate per quad props. Typed arrays are the way to go!

Having a bit of a flashback: has an identical discussion with @mishaelnuh when dealing with gsa analysis result meshes.

I’ll add a section on how to save many objects - hopefully before lunch; you can check the GH/rhino implementation if curious, they deal with this scenario.


#12

Just to add on to this: it’ll be good to merge the quads into a single mesh if possible. This will reduce the payload size significantly.

For nodes, I’m not sure if there’s any way to ‘merge’ this to reduce the payload.


#13

Yeps. @tlmn, I’ve just started writing a generic method to send many objects; it probably won’t be the best for your specific use case.

I’ll also add a NodeArray speckle object of sorts as an example of how to best save large amounts of simple data - the nodes just have, at the end, three coordinate props.

And if I manage to steal more time, a way to get many objects too.

This shaped up as a great discussion!


#14

Okay, i’ve added to the repo a “save all the things” function! It creates a stream with n nodes; you can change n to your liking.

For reference, here’s the crucial part of the code:

    /// <summary>
    /// Orchestrates the saving of many objects. 
    /// </summary>
    /// <param name="account"></param>
    /// <param name="objects"></param>
    /// <returns></returns>
    static IEnumerable<SpecklePlaceholder> SaveManyObjects( Account account, IEnumerable<SpeckleObject> objects )
    {
      Console.WriteLine( String.Format( "Saving {0} objects.", objects.Count() ) );
      Console.WriteLine();
      Console.WriteLine();

      // Step 1: Payload creation.
      // The approach below keeps request sizes around 500kb each.
      // NOTE: Will change in Speckle 2.0

      var objectUpdatePayloads = new List<List<SpeckleObject>>();
      long totalBucketSize = 0, currentBucketSize = 0;
      var currentBucketObjects = new List<SpeckleObject>();
      var allObjects = new List<SpeckleObject>();

      foreach ( var obj in objects )
      {
        long size = Converter.getBytes( obj ).Length;
        currentBucketSize += size;
        totalBucketSize += size;
        currentBucketObjects.Add( obj );

        if ( currentBucketSize > 5e5 ) // restrict max to ~500kb;
        {
          objectUpdatePayloads.Add( currentBucketObjects );
          currentBucketObjects = new List<SpeckleObject>();
          currentBucketSize = 0;
        }
      }

      // add in the last bucket
      if ( currentBucketObjects.Count > 0 )
      {
        objectUpdatePayloads.Add( currentBucketObjects );
      }

      Console.WriteLine();
      Console.WriteLine( String.Format( "Done making payloads ({0} total).", objectUpdatePayloads.Count ) );


      // Step 2: Actually persist the objects, and return placeholders with their ObjectIds.
      // This might take a while.
      var client = new SpeckleApiClient( account.RestApi, false, "console_app" );
      client.AuthToken = account.Token;

      var i = 0;
      var totalObjs = 0;
      foreach ( var payload in objectUpdatePayloads )
      {
        totalObjs += payload.Count;
        Console.Write( String.Format( "Sending payload #{0} ({1} objects, total saved {2}) ...", i++, payload.Count, totalObjs ) );

        var result = client.ObjectCreateAsync( payload ).Result.Resources;
        foreach ( var placehholder in result )
          yield return placehholder as SpecklePlaceholder;

        Console.Write( " done." );
        Console.CursorLeft = 0;
      }
    }

There’s two main steps in there, namely:

  1. create a bunch of payloads based on the object sizes, restricting them to ~500kb (magic number).
  2. send those payloads to the server, and yield return object placeholders.

An important note: this does not use any localcontext caching, bypassing any diffing benefits you might have from not sending previously sent objects. That’s another subject, but the existing implementations all make use of it.

There’s some extra optimisations I’m itching to do in the code above, but for now that should suffice :slight_smile:

[EDIT]: Finally gotten to pad some of the stuff in that repo with text, and update the .net docs. Here it is: https://speckle.systems/docs/developers/dotnet-sdk


#15

Very cool, it seems to work all fine!
I am trying to make use of the SpeckleStructural classes now, but i am struggling a bit to create a mesh. Maybe there is a boilerplate example for this as well? :wink:
I created some structural nodes so far…

SpecklePoint specklePoint = new SpecklePoint { Value = { node.x, node.y, node.z } };
StructuralNode structuralNode = new StructuralNode { basePoint = specklePoint };

The SpeckleMesh object asks for vertices and faces, but I have no idea what they are supposed to look like…


#16

Ok, figured it out myself… with the help of @tluther and Need help with Speckle objects schema/hierarchy