1. I got a patch into FITS to add some basic video metadata extraction. I’d like to take it further to ensure support for the formats that exiftool supports, but it’s a good start.
2. Today I pushed out a first release of ave-sync, a media/xml synchronization tool. Also a good start, and should be a starting place to play with the w3c FileAPI in Firefox 3.6.
3. XForms applications are painful to write, but probably a good choice for XML-based workflows.. more on that later..

var elem = $('#test');
if (elem.css('display') == 'none') {
    elem.css('display', '');
}

/* Support CSS on SVG nodes. */
var origCSS = $.fn.css;
$.fn.css = function(name, value, type) {
	if (typeof name === 'string' && value === undefined) {
		var val = origCSS.apply(this, [name, value, type]);
		return (val && val.baseVal ? val.baseVal.valueAsString : val);
	}
	var options = name;
	if (typeof name === 'string') {
		options = {};
		options[name] = value;
	}
	return this.each(function() {
		if (isSVGElem(this)) {
			for (var n in options) {
				this.style[n] = (typeof options[n] == 'function' ? options[n]() : options[n]);
			}
		}
		else {
			origCSS.apply($(this), [name, value, type]);
		}
	});
}

I make no guarantees that it works on all platforms or browsers, but I mimicked the way Keith implemented .attr() for SVG elements, using the style attribute instead, so it hopefully has similar levels of portability. So far it works for me in Firefox 3.5 and Chrome 3.0. I'm going to guess that it works in Safari, because old code that used the style attribute worked there as well. No idea about IE, because my SVG doesn't load in that to begin with...

In addition to this, I needed to use the plugin to modify existing inline SVG, which seemed daunting given that the plugin normally created its own SVG canvas to render on. However, by hacking together a few calls to some of the internal functions I was able to get a jQuery SVG Wrapper with which I could call methods such as circle(), etc.:

var theDiv = $("#svg-container-div")[0];
$.svg._afterLoad(theDiv, $("#svg-root-element"), {});
var svgRoot = $.svg._getSVG($("#svg-container-div"));
var svgDoc = $("#svg-root-element");
svgRoot._svg = svgDoc[0];
svgRoot.circle(svgDoc[0], 270, 150, 25, {'id' : 'testcircle', 'fill' : "#ffffff", 'stroke' : '#ff0000'});

I'm not sure that this method of doing things is entirely acceptable as far as using the plugin correctly, but for me it successfully modified the DOM and I was able to reference the created elements without incident afterwards. At this point there was one last thing that I wanted to change about the plugin: when creating an SVG element I needed to specify a DOM element, not a jQuery wrapper. Usually this just means that the jQuery wrapper must be de-referenced to get the node, i.e. svgDoc[0] above, but I would get annoyed having to remember to add the array de-reference, so I modified jquery.svg.js again, this time changing the definition of _args, which handles argument decoding for all of the svg functions:

_args: function(values, names, optSettings) {
		names.splice(0, 0, 'parent');
		names.splice(names.length, 0, 'settings');
		var args = {};
		var offset = 0;
		var vOffset = 0;
		if (values[0] != null && (typeof values[0] != 'object' || !values[0].nodeName)) {
			if (!(values[0].jquery && values[0][0].nodeName)) {
				args['parent'] = null;
				offset = 1;
				vOffset = 0;
			}
			else {
				args['parent'] = values[0][0];
				offset = 1;
				vOffset = 1;
			}
		}
		for (var i = 0; i < values.length; i++) {
			args[names[i + offset]] = values[i+vOffset];
		}
		if (optSettings) {
			$.each(optSettings, function(i, value) {
				if (typeof args[value] == 'object') {
					args.settings = args[value];
					args[value] = null;
				}
			});
		}
		return args;
	},

This should provide the same behavior but allow the results of $(selector) to be supplied directly as the first argument to any SVG drawing methods (circle, rect, etc.), but only the first of these will be painted to, which is most useful when selecting an id, not a class. In addition the previous method of directly supplying an SVG DOM element will still work, as will falling back to using the default internal reference that is established when the SVG canvas is created.

In practice, generating high quality animated-style images based on real photographs will require hours of tweaking the palette’s colors, and while I was able to get away with only a few bits of resolution (I used 2 bits), to have something that looks high quality or has a large number of colors, a larger resolution will be necessary. Interestingly enough, for resolutions above 4 bits, the image looks basically the same, but weird in subtle ways that humans have trouble pin pointing. A resolution like this with a very restricted palette (say, the 3 bit one, properly expanded to provide information for all of the combinations) could provide very fine-grained control of the animated styled.

Without further ado, a re-post of the original picture, a much more accurate campaign-style poster, and a video game/commercial version of a portrait of president Obama, along with the palette files that I used for each of them:

Original portrait of President Obama

A Campaign Poster-style Version of the original portrait

A more cartoony, Jet Grind Radio-style version of the Portrait

Palettes:
For the campaign poster (this will need modification on a per-image basis, but the colors should be the same): click here.
For the cartoon-y image (I would recommend making one that is more appropriate for how you want the image to be transformed, this was just a rough starting point): click here.

And, the code. My first contribution to the open source movement, incidentally.

% *************************************************************************
% Image Poster Generator, v2.0
% This filters, decreases the resolution, and then repaints and image with
% values from a specified palette.
%
%   Copyright (C) 2009 Greg Malysa
% *************************************************************************
%    This program is free software: you can redistribute it and/or modify
%    it under the terms of the GNU General Public License as published by
%    the Free Software Foundation, either version 3 of the License, or
%    (at your option) any later version.
%
%    This program is distributed in the hope that it will be useful,
%    but WITHOUT ANY WARRANTY; without even the implied warranty of
%    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
%    GNU General Public License for more details.
%
%    You should have received a copy of the GNU General Public License
%    along with this program.  If not, see < http://www.gnu.org/licenses/ >.
% *************************************************************************

% Specify the names of the palette image, the input, and the output
paletteName = 'palette2bit.png';
inputName = 'obama.jpg';
outputName = 'obama_filt_out.png';
outputType = 'png';

% The darken factor divides all of the pixel values in the image by the
% amount given here in order to change the brightness or darkness of the
% image as a whole.
darken = 1.35;

% Amount of smoothing to apply, between 1 and any integer. Large values
% will make things become far too smooth though, so be careful. 1 does no
% smoothing.
smooth = 4;

% The new target resolution (in bits), which also determines the palette
% size. This must be >= 1 or nothing particularly interesting happens.
% Higher resolutions require larger palettes and allow for more colors.
% With resolution = 8, nothing happens, as all of these images are 8-bits
% per channel anyway (24-bit truecolor images).
targetBits = 2;
paletteSize = 2^targetBits;
divideFactor = 256 / paletteSize;

% The palette itself is a column of bits number of bits by bits blocks,
% where the block number indicates the red channel index, the x offset
% within a block indicates the green channel index, and the y offset
% indicates the blue channel index. For some reason, MATLAB specifies y
% first and x second when accessing an image.
paletteBase = cast(imread(paletteName), 'uint8');
palette = zeros([paletteSize paletteSize paletteSize 3]);
for block = 1:paletteSize
    blockBase = (block-1)*paletteSize;
    for green = 1:paletteSize   %x
        for blue = 1:paletteSize    %y
            palette(block, green, blue, :) = paletteBase(blue, blockBase+green, :);
        end
    end
end

% Format is columns by lines by channels (y, x, 3)
image = imread(inputName)/darken;

% Create a filter coefficient matrix based on the order of smoothness
% requested (this is like a 2-D averager, which is a form of low-pass
% filter). This can be changed to create an edge-detector, for instance.
B = ones(smooth)/(smooth*smooth);

% Apply to each channel separately
imagenew(:,:,1) = filter2(B, image(:,:,1));
imagenew(:,:,2) = filter2(B, image(:,:,2));
imagenew(:,:,3) = filter2(B, image(:,:,3));

% Decrease the resolution based on the bit number requested above, dealing
% with some inconsistencies between MATLAB's casting and traditional
% conventions, and MATLAB's array access mechanisms.
imagenew = cast(imagenew, 'double');
image = cast(floor(imagenew/divideFactor), 'uint8')+1;

% Channel 1 is red, channel 2 is green, and channel 3 is blue
for n = 1:length(image(:,1,1))
    for k = 1:length(image(1,:,1))
        image(n, k, :) = palette(image(n, k, 1), image(n, k, 2), image(n, k, 3), :);
    end
end

% Write out the final image
imwrite(cast(image, 'uint8'), outputName, outputType);

Like

Unlike

Workflows initial came out of “enterprise” systems to managing web services, which moved into the repository in the hands of the repository managers. They establish, in advance, rule based workflows to manage (primarily) submission and dissemination with the Business Process Execution Language (BPEL). While this may be perfect for describing complex interactions, the burden of creating workflows and additional overhead makes this approach seem like overkill.

From the scientific community comes two more basic workflow systems, Taverna and Kepler. The key difference between these systems and BPEL seems to be the intended audience, which for these two applications are the scientists themselves looking to manage and marshal their data in a manner specific to their needs. At this point, many of the applications seem ad-hoc (although, judging by myExperiement, seem to be gathering interest in the scientific community. While certainly applicable to making use of the material in a repository environment, at this point it seems like its application to repository management may be questionable.

A third option is a programmatic workflow engine like Ruote, which allows one to specify business processes in either Ruby, JSON, or an XML syntax, and can be linked with Fedora’s Java Messaging Service using stomp and some Fedora objects.

After the fold, I’ve outlined a very basic Ruote workflow for updating a solr search index every time a Fedora object is updated, similar to the GSearch plugin. Forgive my rather ugly Ruby code, this is just a quick sketch of a possible service.

Here’s a simple Fedora jms/ruote driver:

#--
# Copyright (c) 2009, Chris Beer, chris@authoritativeopinion.com
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#++

require 'rubygems'
require 'uri'
require 'cgi'
require 'net/http'
require 'rexml/document'
require 'rest_client'
require 'stomp'
require 'openwfe/engine'
require 'openwfe/participants'
require 'tempfile'
require 'set'

gem 'soap4r'
require 'FedoraAPIMDriver'
require 'FedoraMessage'

$driver = FedoraAPIM.new
$driver.options["protocol.http.basic_auth"] << ['http://localhost:8080/fedora/services/management', 'fedoraAdmin', 'fedora']

#Workflow engine
$engine = OpenWFE::Engine.new(:definition_in_launchitem_allowed => true)

# Participants
$engine.register_participant('file', OpenWFE::FileParticipant)
require 'participants/dam'
require 'participants/solr'
require 'participants/bagit'

#Message queue
client = Stomp::Client.open "stomp://localhost:61613"

client.subscribe('/topic/fedora.apim.update') do |msg|
  begin
    FedoraMessage.new(msg)
  rescue Exception => e
    #log
    puts e
  end
end

client.join

This triggers the message handler, which asks a Fedora disseminator for an XML workflow definition (which easily allows us to tailor custom workflows per object type, and with some XSLT magic, per message type):

class FedoraMessage

  def initialize( msg )
    @msg = msg
    @doc = REXML::Document.new msg.body
    @repository_uri = REXML::XPath.first( @doc, "//author/uri").text
    @type = REXML::XPath.first( @doc, "//title" ).text
    @pid = REXML::XPath.first( @doc, "//summary" ).text
    @dsID = REXML::XPath.first( @doc, '//category[@scheme="fedora-types:dsID"]/@term' ).to_s

    handle_msg
  end

  #
  # Handle an incoming message
  #
  def handle_msg
    begin
      d = get_definition @pid + '/sdef:WORKFLOW'
      launch_workflow d
      #select $a from <#ri> where $a   $b
   # rescue
      #log
    end

    if self.respond_to? @type
      self.send @type
    end
  end

  #
  # Get the appropriate workflow definition from the repository
  #
  def get_definition( action = nil, params = {} )
    if action.empty?
      action = CGI::escape(@pid)
    end
    RestClient.get( [@repository_uri, "get", action, @type].compact.join('/') + hash_to_qs(params) )

  end

  def hash_to_qs(args={})
  	if args.empty?
  	  return ''
  	end
    '?' + args.map { |k,v| "%s=%s" % [URI.encode(k.to_s),
URI.encode(v.to_s)] }.join('&')
  end

  #
  # Launch a Ruote workflow process
  #
  def launch_workflow( definition, params={} )
    li = OpenWFE::LaunchItem.new definition

    li.repository_uri = @repository_uri
    li.pid = @pid
    li.type = @type
    li.msg = @msg

    params.each do |k,v|
      li[k] = v
    end

    fei = $engine.launch li
  end

#--
# Relationship workflow handlers
#++
[...]
end

The workflow definition returned by this sdef:WORKFLOW may be a way to trigger updating a solr search index (if one wanted to do some more advanced routing outside the scope of gsearch, say):

and, finally, a couple of small solr participants that make the magic happen:

require 'solr'
require 'add_xml_document'

$conn_solr = Solr::Connection.new('http://localhost:8983/solr', :autocommit => :on)

$engine.register_participant(:solr_prepare) do |workitem|
	profile = RestClient.get workitem.repository_uri + "/objects/" +workitem. pid + "?format=xml", :accept => 'text/xml'
    profile = REXML::Document.new profile
    workitem.status = REXML::XPath.first( profile, "//objState").text
end

$engine.register_participant(:solr_update) do |workitem|
    data = RestClient.get workitem.repository_uri + "/get/" + workitem.pid + "/sdef:METADATA/SolrXML"
    doc = Solr::Request::AddXMLDocument.new data
    $conn_solr.post doc
    $conn_solr.commit
end

$engine.register_participant(:solr_purge) do |workitem|
  $conn_solr.delete workitem.pid
end

$engine.register_participant(:solr_close) do |workitem|
  # purge cache?
end

Here is a very basic demo that demonstrates play/pause and seeking to a time. I’ve only tested this in Safari 4/Firefox 3.5, but I believe it should work in earlier versions. There is some __getter_/__setter__ javascript which likely fails in Internet Explorer (although I am aware of a project that offers a workaround, I haven’t tried it out yet).

Like

Unlike