[Gridflow-cvs] [svn] commit: r4338 - /trunk/doc/reference.xml

gridflow-cvs at artengine.ca gridflow-cvs at artengine.ca
Sat Oct 24 14:21:33 EDT 2009


Author: matju
Date: Sat Oct 24 14:21:33 2009
New Revision: 4338

Log:
pus d'<k> ni d'<p>

Modified:
    trunk/doc/reference.xml

Modified: trunk/doc/reference.xml
==============================================================================
--- trunk/doc/reference.xml (original)
+++ trunk/doc/reference.xml Sat Oct 24 14:21:33 2009
@@ -1,10 +1,10 @@
 	<class name="#inner">
-		<p>think of this one as a special combination of <k>[#outer]</k>, <k>[#]</k> and
-		<k>[#fold]</k>. this is one of the most complex operations. It is very useful
+		think of this one as a special combination of [#outer], [#] and
+		[#fold]. this is one of the most complex operations. It is very useful
 		for performing linear transforms like rotations, scalings, shearings,
 		and some kinds of color remappings. A linear transform is done by
-		something called matrix multiplication, which happens to be <k>[#inner * +
-		0]</k>. <k>[#inner]</k> also does dot product and other funny operations.</p>
+		something called matrix multiplication, which happens to be [#inner * +
+		0]. [#inner] also does dot product and other funny operations.
 
 		<method name="init">
 			<arg name="right_hand" type="grid"/>
@@ -18,8 +18,8 @@
 				Splits the Dim(firstB,anyB...) right-hand grid into
 				Dim(anyB...) pieces of Dim(firstB) size.
 
-				On every piece pair, does <k>[#]</k> using the specified
-				op_para operation, followed by a <k>[#fold]</k> using
+				On every piece pair, does [#] using the specified
+				op_para operation, followed by a [#fold] using
 				the specified op_fold operator and base value.
 			
 				creates a Dim(anyA...,anyB...) grid by assembling all
@@ -66,11 +66,11 @@
 				dimensions except the one specified, which will be the
 				sum of the two corresponding one.
 				
-				<p>For example, joining a RGB picture Dim[y,x,3] and a
+				For example, joining a RGB picture Dim[y,x,3] and a
 				greyscale picture Dim[y,x,1] on dimension 2 (or -1) could
 				make a RGBA picture Dim[y,x,4] in which the greyscale image
 				becomes the opacity channel.
-				</p>
+				
 			</method>
 		</inlet>
 		<inlet id="1"><method name="grid"><arg name="grid" type="grid"/></method></inlet>
@@ -105,7 +105,7 @@
 	<class name="#ravel">
 		<inlet id="0"><method name="grid"><arg name="grid" type="grid"/>any grid</method></inlet>
 		<outlet id="0"><method name="grid"><arg name="grid" type="grid"/>
-			like <k>[#redim]</k> but always produce a 1-D grid
+			like [#redim] but always produce a 1-D grid
 			with the same total number of elements.
 		</method></outlet>
 	</class>
@@ -113,22 +113,22 @@
 	<class name="#grade">
 		<inlet id="0"><method name="grid"><arg name="grid" type="grid"/>any grid</method></inlet>
 		<outlet id="0"><method name="grid"><arg name="grid" type="grid"/>
-			<p>splits a Dim[A...,B] grid into Dim[B] vectors,
+			splits a Dim[A...,B] grid into Dim[B] vectors,
 			producing new Dim[B] vectors that each contain numbers from
 			0 to B-1 indicating the ordering of the values. The result is
-			a Dim[A...,B] grid.</p>
-			<p>for example, connecting a [#grade] to a <k>[#outer ignore {0}]</k>
-			to a <k>[#store]</k> object, storing a single vector into <k>[#store]</k>, and
-			sending the same vector to <k>[#grade]</k>, will sort the values of the
+			a Dim[A...,B] grid.
+			for example, connecting a [#grade] to a [#outer ignore {0}]
+			to a [#store] object, storing a single vector into [#store], and
+			sending the same vector to [#grade], will sort the values of the
 			vector. however for higher-dimensional grids, what should go
-			between <k>[#store]</k> and <k>[#grade]</k> to achieve the same result would
-			be more complex.</p>
-			<p>you may achieve different kinds of sorting by applying various
-			filters before <k>[#grade]</k>. the possibilities are unlimited.</p>
-			<p>if you plug <k>[#grade]</k> directly into another <k>[#grade]</k>, you will
+			between [#store] and [#grade] to achieve the same result would
+			be more complex.
+			you may achieve different kinds of sorting by applying various
+			filters before [#grade]. the possibilities are unlimited.
+			if you plug [#grade] directly into another [#grade], you will
 			get the inverse arrangement, which allows to take the sorted values
 			and make them unsorted in the original way. note that this is really
-			not the same as just listing the values backwards.</p>
+			not the same as just listing the values backwards.
 		</method></outlet>
 	</class>
 
@@ -138,15 +138,15 @@
 		</method>
 		<inlet id="0"><method name="grid"><arg name="grid" type="grid"/>any grid</method></inlet>
 		<outlet id="0"><method name="grid"><arg name="grid" type="grid"/>
-			<p>transforms a Dim[A...,B] grid into a Dim[A...,B-1] grid.
+			transforms a Dim[A...,B] grid into a Dim[A...,B-1] grid.
 			There is a projection plane perpendicular to the last axis and
 			whose position is given by the "depth" parameter. Each vector's
 			length is adjusted so that it lies onto that plane. Then the
-			last dimension of each vector is dropped.</p>
+			last dimension of each vector is dropped.
 			
-			<p>useful for converting from 3-D geometry to 2-D geometry. Also
+			useful for converting from 3-D geometry to 2-D geometry. Also
 			useful for converting homogeneous 3-D into regular 3-D, as
-			homogeneous 3-D is really just regular 4-D...(!)</p>
+			homogeneous 3-D is really just regular 4-D...(!)
 		</method></outlet>
 	</class>			
 
@@ -156,7 +156,7 @@
 			<arg name="dim2" type="integer"/>
 		</method>
 		<inlet id="0"><method name="grid"><arg name="grid" type="grid"/>
-			swaps the two specified dimensions; dimension numbers are as in <k>[#join]</k>.
+			swaps the two specified dimensions; dimension numbers are as in [#join].
 		</method></inlet>
 	</class>
 	
@@ -198,7 +198,7 @@
 			<arg name="dims" type="dim_list"/>
 			a list specifying a grid shape that the numbers
 			will fit into.
-			(same as with <k>[#import]</k>)
+			(same as with [#import])
 		</method>
 		<inlet id="0">
 			<method name="grid"><arg name="grid" type="grid(dims...)"/>
@@ -212,7 +212,7 @@
 			<method name="grid"><arg name="grid" type="grid(rank)"/>
 				this grid is a dimension list that replaces the one
 				specified in the constructor.
-				(same as with <k>[#import]</k>)
+				(same as with [#import])
 			</method>
 		</inlet>
 		<outlet id="0">
@@ -221,18 +221,18 @@
 			</method>
 		</outlet>
 
-		<p>example: with a 240 320 RGB image, <k>[#redim 120 640 3]</k> will visually
+		example: with a 240 320 RGB image, [#redim 120 640 3] will visually
 		separate the even lines (left) from the odd lines (right). contrary
-		to this, <k>[#redim 640 120 3]</k> will split every line and put its left half
-		on a even line and the right half on the following odd line. <k>[#redim]</k>
+		to this, [#redim 640 120 3] will split every line and put its left half
+		on a even line and the right half on the following odd line. [#redim]
 		480 320 3 will repeat the input image twice in the output image.
-		<k>[#redim]</k> 240 50 3 will only keep the 50 top lines.</p>
+		[#redim] 240 50 3 will only keep the 50 top lines.
 
 	</class>
 	<class name="#store">
-		<p>A <k>[#store]</k> object can store exactly one grid, using the right
+		A [#store] object can store exactly one grid, using the right
 		inlet. You fetch it back, or selected subparts thereof, using the left
-		inlet.</p>
+		inlet.
 
 		<method name="init">
 			<arg name="contents" type="grid"/>
@@ -244,8 +244,8 @@
 			</method>
 			<method name="grid"><arg name="grid" type="grid(dims..., indices)"/>
 				in this grid, the last dimension refers to subparts of
-				the stored grid. sending a Dim(200,200,2) on a <k>[#store]</k>
-				that holds a Dim(240,320,3) will cause the <k>[#store]</k> to handle
+				the stored grid. sending a Dim(200,200,2) on a [#store]
+				that holds a Dim(240,320,3) will cause the [#store] to handle
 				the incoming grid as a Dim(200,200) of Dim(2)'s, where each
 				Dim(2) represents a position in a Dim(240,320) of Dim(3)'s.
 				therefore the resulting grid will be a Dim(200,200) of
@@ -269,16 +269,16 @@
 			</method>
 			<method name="put_at"><rest name="indices"/>(Future Use): 
 				makes it so that sending a grid to inlet 1 writes into the existing buffer of [#store].
-				<p>
-				example: suppose you have <k>[#store {10 240 320 3}]</k>. then "put_at 3"
+				
+				example: suppose you have [#store {10 240 320 3}]. then "put_at 3"
 				will allow to write a Dim[240,320,3] grid in indices (3,y,x,c) where y,x,c are indices of the incoming grid;
 				in other words, if that's a buffer of 10 RGB frames, you'd be replacing frame #3. Furthermore,
 				it also allows you to write a Dim[n,240,320,3] grid at (3+f,y,x,c) where f,y,x,c are indices of the incoming grid,
 				replacing frame #3, #4, ... up to #3+n-1. Here n is at most 7 because the last frame in the buffer is #9.
-				</p>
-				<p>that way of working extends to other kinds of data you'd put in Grids, in any numbers of dimensions;
+				
+				that way of working extends to other kinds of data you'd put in Grids, in any numbers of dimensions;
 				because, as usual, [#store] wouldn't know the difference.
-				</p>
+				
 			</method>
 		</inlet>
 		<outlet id="0">
@@ -348,13 +348,13 @@
 	</class>
 
 	<class name="#spread">
-		<p>typically you plug a <k>[#for]</k> into this object,
-		and you plug this object into the left side of a <k>[#store]</k>. it will
-		scatter pixels around, giving an "unpolished glass" effect.</p>
+		typically you plug a [#for] into this object,
+		and you plug this object into the left side of a [#store]. it will
+		scatter pixels around, giving an "unpolished glass" effect.
 		
-		<p>if you put a picture in it, however, it will add noise. The
+		if you put a picture in it, however, it will add noise. The
 		resulting values may be out of range, so you may need to clip them
-		using min/max.</p>
+		using min/max.
 
 		<method name="init">
 			<arg name="factor">same as inlet 1</arg>
@@ -371,19 +371,19 @@
 		</outlet>
 
 
-		<p><k>[#spread]</k> scatters the pixels in an image. Not all original pixels
+		[#spread] scatters the pixels in an image. Not all original pixels
 		will  appear, and some may get duplicated (triplicated, etc)
 		randomly. Some  wrap-around effect will occur close to the edges.
-		</p>
-
-		<p> Sending an integer to inlet 1 sets the amount of spreading in
+		
+
+		 Sending an integer to inlet 1 sets the amount of spreading in
 		maximum  number of pixels + 1. even values translate the whole image
-		by half  a pixel due to rounding.</p>
+		by half  a pixel due to rounding.
 
 	</class>
 
 	<class name="#rotate">
-		<p>performs rotations on indexmaps and polygons and such.</p>
+		performs rotations on indexmaps and polygons and such.
 		
 		<method name="init">
 			<arg name="angle" type="0...35999"/>
@@ -398,9 +398,9 @@
 	</class>
 
 	<class name="#remap_image">
-		<p>if you chain indexmap (coordinate) transformations from outlet 1
+		if you chain indexmap (coordinate) transformations from outlet 1
 		to inlet 1, then sending an image in inlet 0 will emit its
-		deformation out of outlet 0.</p>
+		deformation out of outlet 0.
 
 		<inlet id="0"/>
 		<inlet id="1"/>
@@ -408,8 +408,8 @@
 		<outlet id="1"/>
 	</class>
 	<class name="#dim">
-		<p>Returns list of dimensions as a grid. Given a grid sized like Dim(240,320,4), 
-		<k>[#dim]</k> will return a grid like Dim(3), whose values are 240, 320, 4. </p>
+		Returns list of dimensions as a grid. Given a grid sized like Dim(240,320,4), 
+		[#dim] will return a grid like Dim(3), whose values are 240, 320, 4. 
 
 		<method name="init">
 			no arguments.
@@ -428,8 +428,8 @@
 	</class>
 
 	<class name="#type">
-		<p>gives a symbol representing the numeric type of the grid received.
-		</p>
+		gives a symbol representing the numeric type of the grid received.
+		
 		<outlet id="0"><method name="&lt;numeric type symbol&gt;"/></outlet>
 	</class>
 
@@ -440,15 +440,15 @@
 		</method>
 	</class>
 	<class name="#apply_colormap_channelwise">
-		<p>This object is useful for color correction. For each pixel
+		This object is useful for color correction. For each pixel
 		it takes it apart, looks up each part separately in the colormap,
 		and constructs a new pixel from that. You may also color-correct
-		colormaps themselves.</p>
-
-		<p>Only works for things that have 3 channels.</p>
-
-		<p>Note: if you just need to apply a palette on an indexed-color
-		picture, you don't need this. Just use #store instead.</p>
+		colormaps themselves.
+
+		Only works for things that have 3 channels.
+
+		Note: if you just need to apply a palette on an indexed-color
+		picture, you don't need this. Just use #store instead.
 		
 		<inlet id="0"><method name="grid">
 			<arg name="grid" type="grid(rows columns channels)"/>
@@ -484,7 +484,7 @@
 	</class>
 
 	<class name="#yuv_to_rgb">
-		<p>note: may change slightly to adapt to actual video standards.</p>
+		note: may change slightly to adapt to actual video standards.
 		<inlet id="0"><method name="grid">
 		<arg name="grid" type="grid(rows columns {y u v})"/></method>
 		</inlet>
@@ -494,7 +494,7 @@
 	</class>
 
 	<class name="#rgb_to_yuv">
-		<p>note: may change slightly to adapt to actual video standards.</p>
+		note: may change slightly to adapt to actual video standards.
 		<inlet id="0"><method name="grid">
 		<arg name="grid" type="grid(rows columns {red green blue})"/></method>
 		</inlet>
@@ -503,8 +503,8 @@
 		</method></outlet>
 	</class>
 	<class name="#convolve">
-		<p>this is the object for blurring, sharpening, finding edges,
-		embossing, cellular automata, and many other uses.</p>
+		this is the object for blurring, sharpening, finding edges,
+		embossing, cellular automata, and many other uses.
 <!--NYI
 		<attr name="seed">
 		
@@ -522,8 +522,8 @@
 				splits the incoming grid into dim(rest...) parts.
 				for each of those parts at (y,x), a rectangle of such
 				parts, centered around (y,x), is combined with the
-				convolution grid like a <k>[#]</k> of operation op_para. Then
-				each such result is folded like <k>[#fold]</k> of operation
+				convolution grid like a [#] of operation op_para. Then
+				each such result is folded like [#fold] of operation
 				op_fold and specified base. the results are assembled
 				into a grid that is sent to the outlet. near the borders of
 				the grid, coordinates wrap around. this means the whole grid
@@ -561,8 +561,8 @@
 			produces a grid like the incoming grid but with
 			different constrast.
 			</method>
-			<p><k>[#contrast]</k> adjusts the intensity in an image.
-			resulting values outside 0-255 are automatically clipped.</p>
+			[#contrast] adjusts the intensity in an image.
+			resulting values outside 0-255 are automatically clipped.
 		</inlet>
 		<inlet id="1">
 			<method name="int">
@@ -587,9 +587,9 @@
 	</class>
 
 	<class name="#posterize">
-		<p><k>[#posterize]</k> reduces the number of possible intensities in an image;
+		[#posterize] reduces the number of possible intensities in an image;
 		it rounds the color values.The effect is mostly apparent with a low
-		number of levels.</p>
+		number of levels.
 
 		<method name="init">
 			<arg name="levels">same as inlet 1</arg>
@@ -614,15 +614,15 @@
 		<outlet id="0">
 		</outlet>
 
-		<p>example: simulate the 216-color "web" palette using 6 levels.
-		simulate a 15-bit display using 32 levels.</p>
+		example: simulate the 216-color "web" palette using 6 levels.
+		simulate a 15-bit display using 32 levels.
 	</class>
 
 	<class name="#solarize">
-		<p>makes medium intensities brightest; formerly brightest colours
+		makes medium intensities brightest; formerly brightest colours
 		become darkest; formerly darkest stays darkest. This filter is linear:
 		it's like a 200% contrast except that overflows are <i>mirrored</i>
-		instead of clipped or wrapped.</p>
+		instead of clipped or wrapped.
 		<inlet id="0">
 			<method name="grid">
 				<arg name="grid" type="grid(rows columns channels)"/></method>
@@ -637,7 +637,7 @@
 		<inlet id="0">
 			<method name="grid">
 				<arg name="grid" type="grid(y x {y x})"/>
-				result from a <k>[#for {0 0} {height width} {1 1}]</k>
+				result from a [#for {0 0} {height width} {1 1}]
 			</method>
 		</inlet>
 		<outlet id="0">
@@ -676,13 +676,13 @@
 	</class>
 
 	<class name="#text_to_image">
-		<p>inlet 2 receives a font grid, for example, [#in grid file lucida-typewriter-12.grid.gz]</p>
-		<p>inlet 1 receives a 2 by 3 matrix representing the colours to use (e.g. (2 3 # 0 170 0 255 255 0) means yellow on green)</p>
-		<p>inlet 0 receives a bang, transforming the data into an image suitable for #draw_image.</p>
+		inlet 2 receives a font grid, for example, [#in grid file lucida-typewriter-12.grid.gz]
+		inlet 1 receives a 2 by 3 matrix representing the colours to use (e.g. (2 3 # 0 170 0 255 255 0) means yellow on green)
+		inlet 0 receives a bang, transforming the data into an image suitable for #draw_image.
 	</class>
 	<class name="#hueshift">
-		<p>inlet 1 receives an angle (0..36000)</p>
-		<p>inlet 0 receives a RGB picture that gets hueshifted by a rotation in the colorwheel by the specified angle; it gets sent to outlet 0.</p>
+		inlet 1 receives an angle (0..36000)
+		inlet 0 receives a RGB picture that gets hueshifted by a rotation in the colorwheel by the specified angle; it gets sent to outlet 0.
 	</class>
 	<class name="pingpong">
 		Transforms linear counting (0, 1, 2, 3, 4, ...)  into a back-and-forth counting (0, 1, 2, 1, 0, ...)
@@ -742,10 +742,10 @@
 		</outlet>
 	</class>
 	<class name="fork">
-		<p>Every incoming message is sent to inlet 1 and then sent to
+		Every incoming message is sent to inlet 1 and then sent to
 		inlet 0 as well. Messages remain completely unaltered. Contrast
 		with PureData's "t a a" objects, which have the same purpose but
-		transform bangs into zeros and such.</p>
+		transform bangs into zeros and such.
 
 		<inlet id="0"><method name="(any)"/></inlet>
 		<outlet id="0"/>



More information about the Gridflow-cvs mailing list