dynamods / dynamo Goto Github PK

Should wrap call to SelectionHelper in an IdlePromise

Example to Introduce:

Form creation
Level creation
Panelization
Watch of panel values
Analysis Visualization coloring of elements by value
Structure - Load Takedown (project storm?)

Allows users to create sub-classed node dlls for consumption by other users.

A 'zi' node in the ReferencePointGridXYZ would be very useful for allowing quicker 3D arrays. Great work!

rebuild arduino node and test with current arduino/processing

This would allow us to configure the behavior of certain nodes. For example: right now the slider node allows you to set a minimum and maximum value, but you cannot set the actual value exactly. With a right click option one could input this information

Also one could right click the node connectors to set them to values. Right now you have to pull number or other nodes to set inputs to certain nodes. One should be able to set these inputs without necessarily having to place a node.

add a node that reads from an image and returns a list of RGBs/greyscale values, combine with watch file node to setup a loop where user can paint program and see results update in dynamo. greyscale values mapped into an instance param on curtain panel

for example:

• read EUI values from Conceptual Energy Analysis results
• read structural analysis results from robot or etabs

Add build script to update the readme change list with all changes since prior commit.

input - a family instance
output

• curve references extracted from visible model lines in the family symbol,

Right now only "saveas" is available.

current SR example shows a brute force approach for one parameter, show how to generalize, add more params to domain, switch to different optimization strategies.

Represents the contents of a file, triggers a dynamic run when the file has been changed. (Uses a filewatcher under the hood)

We should either write this as a node or include the .dyf with the distribution.

Instead of having a text field containing the script, it takes an extra argument expecting a string containing the script.

When loading new .dyn or .dyf files, nodes are always colored gray. There's a missing ValidateConnections() call somewhere...

rebuild kinect node and test

Happens often w/ sliders, less often with text boxes.

I think what's happening is a race condition between the UI thread and the evaluation thread. Evaluate thread fetches UI value, UI thread then updates the value, and then evaluate thread marks it as clean after using the old value.

Solution: wrap evaluate thread in UI dispatcher such that UI is fetched and marked clean in the UI thread. This way, the UI updates before the evaluation (and the latest value is fetched) or the old value is fetched and the node is marked clean before the change happens and it becomes dirty again (the queue will then rerun it to get the changes).

Hi there,

got a suggestion for AddElement_Click(object sender, RoutedEventArgs e) in the dynBench.xaml.cs.

currently you won't make it past the builtinTypes[mi.Header.ToString()] for types that are in the userTypes collection.

Is the User Node supposed to work? Even as a node that doesn't do anything? Here it doesn't manage to initialize a new node.

Kind regards,
Gregor

    private void AddElement_Click(object sender, RoutedEventArgs e)
    {
        System.Windows.Controls.MenuItem mi = e.Source as System.Windows.Controls.MenuItem;

        TypeLoadData tld = null;
        if (builtinTypes.ContainsKey(mi.Header.ToString()))
        {
            tld = builtinTypes[mi.Header.ToString()] as TypeLoadData;
            ...
        }
        else if (userTypes.ContainsKey(mi.Header.ToString()))
        {
            tld = userTypes[mi.Header.ToString()] as TypeLoadData;
            if (tld != null)
            {
                dynElement newEl = AddDynElement(tld.t, tld.assembly, mi.Header.ToString(), Guid.NewGuid(), 0.0, 0.0);
                ...
            }
        }
    }

a node to write the contents of a list to a csv file

Working with Dynamo in the family environment is nice, but being able to work in the project could open a whole lot of opportunities.

For some reason, my machine returns my laptop screen (my secondary monitor) as as monitor[0]. All the documentation says that the windows primary monitor (the one with the task bar on it) should be monitor[0]. So, dynamo gets maximized to my main screen, but I want to see if this is the case with other users. I use BootCamp on a macbook pro, so it's monitor array might just be cocked.

Alter the .dyn to included references to loaded .dyf files.

Every node is named according to its type, but it would be nice to rename them to allow us to clarify the function of a particular part of the visual program. The text notes would help with this, but it would be nicer to have the note stick with a node.

Right now we have to select nodes one by one to move them. It would be beneficial to be able to select multiple nodes at once to reorganize them as the design process develops.

We should also be able to select nodes and copy / paste them to a new location. You don't always know that you want to make an user node when you start, and right now you have to start all over if you placed nodes in the home canvas.

Nodes all error with thread ownership exception. Evaluation sometimes doesn't succeed.

Right now the pan functionality is locked to the starting axis on the upper left corner of the canvas. Once you start laying out your program we often need to rearrange the nodes and it is awkward to have to keep moving nodes to the right.

take two doubles as inputs, start and end,
take another number in - x (like a floor to floor height)

make as many new doubles as you can, starting from 'start' and adding 'x' until you hit 'max'
return list of doubles.

Create a divided path from a curve element or set of curve elements

create new raspberry pi node for dynamo. assigning to ian because he has one

update and finish version i started before in side branch

External Events framework
The External Events framework is a new API framework tailored for asynchronous processing such as that which is needed to support modeless dialogs. It operates similarly to the Idling event with default frequency.
With this framework, instead of implementing an event handler and implementing the handler to do nothing when there is no activity in your dialog, instead you do the following:

1. Implement an external event by deriving from the interface:
   • IExternalEvent
2. Create an ExternalEvent with
   • ExternalEvent.Create()
3. When an event happens in your modeless UI where a Revit action needs to be taken, call
   • ExternalEvent.Raise()
4. Revit will wait for an available Idling timecycle and call the implementation of your event:
   • IExternalEvent.Execute()
   This framework is more useful for modeless dialog developers because you can skip the default no-op implementation when nothing has happened, and tell Revit when there is some work you need to do in Revit. It also saves on the time required for Revit to make repeated calls to the Idling event when there is no actual work to be done.

Separate the Revit logic from the interface.

i have this 3/4 done

add new examples shown in VasariTalk to samples in WIP and on wiki

dynRelaxation node implements a basic particle system
input - list of ref points get mapped to particles (use Revit XYZ class for now for Vector3d)
input - list of line-bypoints mapped to springs
input - timestep - seperate node to set ms, either implement a timer node or set ms as a double
fixity - read parameter / data set on user-created ref points (bool fixed)
gravity and forces - hard code gravity and drag for now in the PS. solver can handle wind as well but let's get the basics going first.

internals - solver - verlet or rk4
particle.cs
spring.cs
particlesystem.cs

dynRelaxation node is responsible for managing inputs, instantiating the PS, creating particles from ref points and springs from lines, and then calling the update as part of Evaluate. after PS update step, PS update step needs to return particle list. dynRelaxation Evaluate() will take particle list with updated positions and then map that back to ref points to update their position. Curve-by-points will update automatically, no need to make spring length back to CBPs. on evaluate all we are doing is updating the position of existing ref points so refresh should be fairly quick, update ref points individually or as a group. question is do we need nested transactions to do this. Need to ask Stephen/Peter about threading.

basic use cases:

• 1d - catenary curve - linear array of ref points connected by line-by-points. fix ends, run sim, watch hang
• 2d - grid - 2d array of ref points connected by line-by-points. fix corners, run sim, watch hang.

This would clean up the canvas. The feature could be inplemented via a right-click option, and the metaphor could we of a "wireless" connection.

I have a level node already in, need a level by selection node too.

Currently the combine node allows for multiple input ports labeled as "List 1" "List 2" etc. Or, you can have one input port called "Lists" that takes a bunch of lists as inputs. When you reopen a workflow where you've made the combine node take "Lists" it still has "List 1" and "List 2" and the wokflow fails to evaluate because the second of the two ports has no input. The behavior to save the state of a node with a mutable port collection should extend to other nodes that exhibit similar behavior, i.e. family instance parameter mapper.

Right now we have to have a collection of cascading "Set Parameter" nodes to set multiple parameters in the same family.

Create a new divided surface from a face or set of faces

Where should we be referencing the RevitAPI.dll and RevitUIAPI.dll files from? The Vasari SDK files seem to be based on 2012 and have a bunch of errors when referenced.

Thanks,
-Danny

Right now we can only set instance parameters.