Re: [agtk-devel] [gilles@harfang.homelinux.org: AG Structure]

[Haejoong L. <hae...@un...>]

Hi Gilles,

>>For this question, please check:
>>
>>   http://agtk.sourceforge.net/doc/aglib/2.0/newformat.html
>>
>>    
>>
>
>I've had a quick look on that page. This seems really nice.
>I think there might be some mistakes in the last code example ('test.cc'):
>(1) in the first 2 lines, the #include directive is followed by nothing.
>(2) assuming Load and Store are methods, shouldn't they be called on some object?
>  
>

(1) was an HTML formatting problem.  Thanks for noticing me the error.
As for (2), note that that Load and Store are also defined in AGAPI.  
The test program is using AGAPI.

>That is indeed one of our main concerns:  How to produce an easy to read 
>transcript (i.e. compute the orthographic offsets) from the data stored in 
>the graph. But for this you must be able to sort the annotations.
>This was the purpose of my questions on the structure of an AIF file: Is 
>there a conventional way ("conventional" in the sense that it is not enforced
>by the DTD) to represent chronologically ordered annotations?
>>From my first trials (using XQuery), it seems that designing the sorting procedure 
>might not be obvious in the general case (i.e. when not all the anchors used have
>an offset).
>

...snip...

>
>  
>
>I understand that the AIF format does not prevent this sort of representation, 
>but then my question is, as above: Is there a conventional way to structure an 
>AIF file so that aglib is able to answer queries on the relative order of the 
>annotations that compose a graph?  For example, how would it be possible, for 
>a drawing program using aglib, to draw the example graphs given in Bird's and 
>Liberman's article "A Formal Framework for Linguistic Annotations"?
>
>Or is it that each project must provide its own representational convention (like
>in your "right_sibling" pointers example) to be able to recover some needed 
>structure (for example: which annotation comes before which)?  I think that the 
>reason AG is an attractive concept is because it really can represent a graph; 
>but then 
>(1) the in-memory graph structure dealt with by aglib should be self-sufficient 
>    to answer a query about the relative order of two annotations (i.e. starting 
>    from the first annotation, can I reach the second by following the edges of 
>    the graph)
>(2) there should be a way to represent a graph in AIF such that the appropriate
>    in-memory structure can be recovered.
>
>If you get what I mean (I'm afraid it might not be as clear as I would),
>does this make any sense to you?
>

Yeah, I know why AG is attractive, but often the artifacts like 
"right_sibling" are inevitable.  Sometimes I wonder if it's a limitation 
of AG.

Have you given a thought to the anchored AG?  I think it could be what 
you are looking for.  Although there are still cases where you can't 
compute the order of two annotations, it largely increases the 
computability of orders of annotations.

Folks, can anybody give him a definite answer, or should he devise his 
own convention?

Thanks,
Haejoong