The library uses JSch (Java Secure Channel).
Copyright (c) 2002,2003,2004,2005,2006,2007 Atsuhiko Yamanaka, JCraft, Inc.
importsftp.*;
Sftp sftp;void setup(){
size(200,200);
background(0);// Create the SFTP object// if 3rd arg = false, you must set the password in your code// if 3rd arg = true, you will be prompted to enter your password
sftp =new Sftp("www.hostname.com","login", true);// sftp.setPassword("XXXXXX");
sftp.start();// start the thread
noLoop();}void mousePressed(){// At any point you can execute an SFTP command // Not all commands are currently implemented// but you do have "ls" and "get"// Gosh, I should implement "put", sorry!
sftp.executeCommand("ls");
sftp.executeCommand("get file.txt");}
We’ve successfully added support for passing larger amount of data across clients in the multi-screen framework and this has led to some nice experiments, including having one client capture video for the entire system. The demo below involves 3 client computers, 6 LCD screens, and 2 video cameras. Did I mention this is all works with Processing???
Now, I have to admit. I have a problem. When I had one screen, I wished for two. When two came, I wished for 3. Then 6. Now, I wish for 12. (Well, I would really quite prefer in the vincinity of 96 screens, but I have to be realistic.)
“WordNet is a large lexical database of English, developed under the direction of George A. Miller. Nouns, verbs, adjectives and adverbs are grouped into sets of cognitive synonyms (synsets), each expressing a distinct concept. Synsets are interlinked by means of conceptual-semantic and lexical relations.”
I wonder how useful it would be to create a Processing library with some basic WordNet functionality (or that simply exists as an interface to JWNL for all things WordNet.) There are many lovely examples of text-based Processing work out there. Two that jump to mind are State of the Union by Brad Borevitz as well as anything ever made by Ariel Malka.
The power of WordNet is not that it provides access to word meanings (which it does), but that it provides information about the relationships between words (and when I say “word,” I really mean set of synonyms, or synset). It’s the myspace for semantic concepts. You’re probably familiar with synonyms and antonyms. In addition, WordNet provides links for less well-known semantic relationships, such as hypernymy, hyponymy, meronymy, troponymy, and entailment. Do I see some sort of tree / network visualization in Processing’s future?
Wherein we pick a name we like (Tech Trek: Inside ITP) and catch ITP researcher and teacher Dan Shiffman working on 6, 32-inch TVs. His project is was just up and running when we talked to him. It’s an open source Java framework for spanning real-time graphics applets/applications across multiple screens.
Coming soon to a Processing library folder near you, I’m pleased to announce a new project I’m developing at ITP with Chris Kairalla, tentatively titled “Most Pixels Ever.”
“Most Pixels Ever” (not to be confused with “Best Pixels Ever”) is an open source Java framework for spanning real-time graphics applets/applications across multiple screens. The above video is a quick demonstration of the first prototype. Three client applications on three Mac Pros connect to six 32 inch LCD displays (each Mac has a dual video card, but this could just have easily work with 6 client machines). One of the Macs is also running a server application. The server tells each client about the master pixel dimensions of all the screens combined (here 8160×768). The client keeps track of its own location dimensions (say 2720×768) as well as its location with in master dimensions (say 5040,0). The server keeps everyone in line, making sure that frames are rendered in sync.
In theory, the system is scalable to whatever your network will allow. If you want to run 100 LCD displays off of 100 mac minis, you can (and I really hope you do.)
We’ve got quite a bit of testing and tweaking to do before we release the library to the public along with documentation and instructions. So stay tuned!
I was just settling into a quiet evening of reviewing material for my A to Z class tomorrow when I stumbled across something quite shocking.
Mind you, I was in a fragile state, having finally released myself from a rather unhealthy personal obsession with the StringTokenizer, silently weeping (inside) while adjusting the examples to use split with regular expressions.
Back in the old days, when using some form of Java Collection, one was required to cast elements retrieved from that collection into the type of element stored in the collection. According to Sun’s site: “Besides being inconvenient, this is unsafe. The compiler does not check that your cast is the same as the collection’s type, so the cast can fail at run time.”
Generics allow you to specify the type of a objects to be stored in a collection to the compiler. This means that the compiler can confirm that you are using the collection consistently and cast the values itself as they are taken out of the collection.
What was:
ArrayList strings =newArrayList();
strings.add("Hello World!");String s =(String) strings.get(0);
is now:
ArrayList<String> strings =new ArrayList<String>();
strings.add("Hello World!");String s = strings.get(0);
Frankly, the syntax is a little ugly and awkward (esp. when you start getting into collections with keys and values), but I’ll play along for now. . .
It’s been a while since I published a new work. But there’s nothing like a deadline. A year ago, I installed three of my works at the Jepson Center for the Arts in Savannah, GA. Since the installation was set to run for three years, it seemed like a nice, altogether reasonable thing to say “Well, how about in a year, I come back and swap out one of my old pieces for a new one?” A year quickly fills up with teaching, working on a book, and living la vida loca. Nevertheless, here I am, a week from heading back down to Savannah and spending all day programming again.
When I first developed the two generative pieces, swarm and mosaic, I always imagined them part of a series of three. I was working on my ITP thesis, an exploration of generative systems in the production of real-time non-photorealistic imagery. Flocking. Cellular Automata. The usual. Having only one semester, I never made it to adopting their formulaic sibling, Fractals (I think I might have to name a pet Fractals some day, kind of like Freckles, only nerdier.) Looking at how L-Systems work (which we do in my nature of code class), the idea was to create a generative garden of abstract and algorithmic trees, shrubs, and flowers, growing on and about the screen, creating a nice little digital painting of the viewer.
Some screenshots and a video (first one is me, second one is my dog, Petey “Fractals” Caloyeras):
I’m not entirely satisfied with the result, as of yet. It’s nice to look at, but it’s just the swarm effect duplicated, only instead of smearing pixels with in a flocking pattern, they are smeared in a recursive tree pattern. I like to keep things simple, but perhaps augmenting the interaction in such a way that, at the very least, the viewer has a sense of “planting seeds” might improve the experience. I also intend to try some more sophisticated plant patterns, but with only one day of experimenting, keeping it simple for now. . .
Ok, so I will probably go back to using the video comments plug-in for posting video, but how could I live one more day without at least publishing one video to YouTube??
A first pass at my Neural Networks in processing tutorial is ready for public consumption. So, before you go and consume a turkey, consume this link. And let me know if it makes any sense at all. . .? The examples are still trivial — Linear classification, Solving XOR — but I hope to develop some more advanced pattern recognition examples soon!
Is it a penguin? A tooth? A surfer from the future? Whatever it is, this announcement sure does make me happy. Read more about it at Create Digital Motion, one of my new favorite blogs!
