I want to proceduraly generate textures made by GIMP. I know there is GIMP library for Python which can call GIMP's tools with parameters. If I know what tools (with parameters) GIMP used then I should be able to reproduce image programatically (procedurally generate image). How to record what tools (with parameters) GIMP uses while I am drawing image?
I think you are referring to a GIMP equivalent of Actions in Adobe Photoshop. AFAIK, they are called GIMP Scripts.
This is a starting point, if you are going to make your own Scripts
Related
I have tried using different MindMap diagrams and it looks like this field didn't get enough attention in software development community, so I cannot find enough info on other resources.
Anyway, I use PlantUML to draw Mind Map diagram. The issue is that I draw it from the website, so it gets nested to 6th level and deeper. In PlantUML I can use it either as plain PlantUML or save as PNG file. (It doesn't seem support other formats)
There are several questions but the main is, how can I save/split it as a multi-page?
Sub-questions which also can be answers in my case, how to organise Mind Map to make it readable in PNG? How to keep it on single PNG? Are there other formats supported?
NOTE:
Even though this question asks about specific tool (PlantUML), this question touches fundamental question. I struggle to have this peace ready in my software and it is crucial part before the release.
UPDATE 1:
Here is example of the PNG file I receive after conversion .puml to .png:
NOTE: The .puml file was too long for plantuml.com to render. The length of the file is 16754 lines.
As I wrote in my comment above, SVG representations of a large Mind Map might be more easily navigated:
Try PlantUML using VSCode and this extension: https://marketplace.visualstudio.com/items?itemName=jebbs.plantuml
If you use Local rendering (you have to install PlantUML and configure it on your local machine) you can use large diagrams and produce SVG output. I don't use the IntelliJ plug-in, so I'm not sure if you can also generate SVG with it.
The toolbox packaging functionality new in R2014b looks pretty nice.
However, you seem to be able to package a toolbox only via the toolbox-packaging GUI.
I'd like to be able to create a .prj file interactively using the GUI, and then programmatically package the toolbox using this .prj file, incorporating this programmatic step into a wider build process (which also includes checking things out, running a unit-test suite etc).
Does anyone know of a way to do this (documented or not, supported or not)?
I took a look at MATLAB\R2014b\toolbox\matlab\toolbox_packaging\+matlab\+tbxpkg\+internal\create.m - this seems to mostly do the job, but it requires that the .prj file is in a specific location relative to the toolbox folder.
I was hoping for something similar to the app-building classes such as matlab.apputil.
As of R2016a there is new functionality to programmatically package a toolbox.
It's very slick and cross browser/platform at the click of a button, which is leading non-technical types to conclude the entire engine is intrinsically better than what we use now. Is it simply that they've taken the time to implement all the per-browser/OS plugin versions of Unity WebPlayer and polish it, or is there anything deeper in the way the engine architecture is set up?
Unity takes scripts written in C#, UnityScript (based on JavaScript), or Boo (based on Python), and compiles them into mono assemblies. Those assemblies + the 3d models, sounds, and textures required by your game are compressed into a .unity3d file that is loaded by their browser plugin. Since almost all of the game's logic is in managed mono assemblies it runs cross platform with very few platform specific quirks.
They've recently rewritten their plugin detection and installation code so that it is very easy to drop a block of javascript into a web page that shows Unity content if the user has the plugin, or other content (image, flash, video) if they don't. I believe their plugin supports all A-class browsers on Mac and Windows, and the plugin can be installed without restarting the browser.
One advantage of the Unity engine is that you can take a lot of off-the-shelf managed assemblies and include them in your project and call them from Unity code. But you have to be aware that these assemblies can really bloat the size of the .unity3d file.
Another advantage is that you can easily write components that expose tunable parameters that can be modified by non-technical people.
And yet another advantage is that a well written project can be ported to/from iPhone, Standalone, Android, Web, etc. in under a day. I've personally done iPhone to Web by just modifying my input handler and changing texture compression.
One big disadvantage is that since the application is running managed code it is not too difficult for a curious or malicious person to decompile the assemblies into completely readable code. So you need to think about what someone could do with that info (cheat in multiplayer, write bots, falsify high scores, etc.). It is possible to obfuscate your assemblies, but it isn't trivial to add this step to your build process.
I'd like to post-process log files and extract node data and transitions, and then graph them in a gui of some kind. So, I'd like to programmaticly draw bubble diagrams, maybe with animations showing packets going from node to node.
Ideally, perl or java would be the language of choice, but anything that runs on a linux platform would be fine.
What is the best library for this kind of thing?
Java Solutions
Two possibilities in Java include Prefuse and Visual Library. They both have the ability to display graphs with some animation ability. Prefuse has better graph layouts. Visual Library is more Swing-like if you are used to Swing development.
Adobe Flash
If you are willing to work with Adobe Flash, Flare is probably a little more suited to your task as it has better animation capabilities and has good graph layouts.
Animation Libraries
If your diagrams are fairly simple, you could create your own diagrams and use the Timing Framework or Trident for animation.
Other
Some other possibilities include Processing and JavaFX. Javascript libraries include ProcessingJS and Protovis.
Graphviz will draw you static diagrams. It can't do animations as far as I know.
If you can convert the output into graphviz dot format (graphviz) than you can use idot incremental viewer (iDot_incremental_viewer) which uses prefuse behind the scenes and it's completely free. The only thing you need to do here is to convert the output in simple dot file. Rest will be taken care of incremental viewer.
Are Adobe's plugin architectures for Photoshop and Lightroom related in any way? If I have source code for a plugin, that works with PS 3.0-CS3 as well as PS Elements 6.0 can I use it with Lightroom directly? If not, what would I have to modify?
No.. lightroom plugins are written in the scripting language lua, photoshop plugins are written in C++.
As noted by kasperjj, the Lightroom plugins are written in Lua so there is not a direct way to convert something from Photoshop over to Lightroom. Additionally, as per the Adobe Lightroom Developer Center, the only features that are extendable in the current SDK are the export functionality, metadata, and web engine functionality.
As pointed out by Rob, the Lightroom SDK does not expose any interface that allows manipulations of the image files themselves. Partly this is because Lightroom is a non-destructive editor. None of the edits made in its Develop module are applied to the original image file; they are applied to the file generated when the image is exported, printed, or used in a web gallery.
That said, there are examples of export plugins that manipulate the image after Lightroom has finished applying its adjustments. In principle, it would be possible to create a host application that loaded a Photoshop plugin and applied it during Lightroom export. It might even be possible to use Photoshop itself as that host application...