Update of /cvsroot/pure-data/externals/gridflow/optional/rblti
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv23121
Added Files:
LICENSE Makefile gen_ltilib_classes.py lti_manual.h rblti.i
std_list_ruby.i
Log Message:
0.8.1
--- NEW FILE: gen_ltilib_classes.py ---
#!/usr/bin/env python
#******************************************************************************
# rblti, Copyright 2005 by Mathieu Bouchard and Heri Andria
# pylti, Copyright 2005 by Michael Neuroth
# a wrapper for ltilib using SWIG
#******************************************************************************
#
# Tool to generate header files for SWIG to process the nested classes "parameters"
#
# 1) generate XML files for the ltilib with doxygen (tested with version 1.4.3) (use this switch in doc.cfg file: GENERATE_XML = YES)
# 2) generate the new header files for SWIG with this python script
from xml.dom import minidom
import os
import sys
from distutils.text_file import TextFile
str_version = '0.32'
basedir=None
# handle the settings: WORKAREA has to be defined !
if len(sys.argv)>1:
basedir = sys.argv[1]
else:
workarea = os.getenv('WORKAREA')
# is pylti not part of the ltilib ? Yes --> than we need a directory structure of WORKAREA_PATH/import/ltilib/xml
if workarea<>None:
basedir = workarea+os.sep+'import'+os.sep+'ltilib'+os.sep+'xml'+os.sep
# check if we are in misc directory of the ltilib distribution (ltilib/misc/pylti)
# very simple way: navigate up and navigate down again
else:
strCheckPath = '..'+os.sep+'..'+os.sep+'misc'+os.sep+'pylti'+'-'+str_version
try:
# try to read lti.i, this is a good indication of a pylti directory
aTestFile = TextFile(filename=strCheckPath+os.sep+'lti.i')
basedir = '..'+os.sep+'..'+os.sep+'xml'+os.sep # move up ltipy and misc directory
except IOError: pass
output_dir = 'generated'
#output_dir = 'generated_ruby'
def f(x): return 'classlti_1_1'+x+'.xml'
#def g(x): return 'lti::_'+x+'::_'+x+'_parameters'
def g(x): return 'lti::_'+x+'::'+x+'_parameters'
# list of tuples with ( xml-file-name, full-qualified-name of the base class )
lst = [ (f('functor_1_1parameters'), 'lti::ioObject')
, (f('ioFunctor_1_1parameters'), g('functor'))
, (f('ioImage_1_1parameters'), g('ioFunctor'))
, (f('usePalette_1_1parameters'), g('functor'))
, (f('segmentation_1_1parameters'), g('functor'))
, (f('regionGrowing_1_1parameters'), g('segmentation'))
, (f('meanShiftSegmentation_1_1parameters'), g('segmentation'))
, (f('kMeansSegmentation_1_1parameters'), g('segmentation'))
, (f('whiteningSegmentation_1_1parameters'), g('segmentation'))
, (f('csPresegmentation_1_1parameters'), g('segmentation'))
, (f('colorQuantization_1_1parameters'), g('functor'))
, (f('kMColorQuantization_1_1parameters'), g('colorQuantization'))
, (f('viewerBase_1_1parameters'), g('functor'))
, (f('externViewer_1_1parameters'), g('viewerBase'))
, (f('objectsFromMask_1_1parameters'), g('segmentation'))
, (f('objectsFromMask_1_1objectStruct'), 'lti::ioObject')
, (f('tree_1_1node'), 'lti::ioObject')
, (f('featureExtractor_1_1parameters'), g('functor'))
, (f('globalFeatureExtractor_1_1parameters'),g('featureExtractor'))
, (f('localFeatureExtractor_1_1parameters'), g('featureExtractor'))
, (f('geometricFeatures_1_1parameters'), g('globalFeatureExtractor'))
, (f('localMoments_1_1parameters'), g('localFeatureExtractor'))
, (f('chromaticityHistogram_1_1parameters'), g('globalFeatureExtractor'))
, (f('modifier_1_1parameters'), g('functor'))
, (f('polygonApproximation_1_1parameters'), g('modifier'))
, (f('transform_1_1parameters'), g('functor'))
, (f('gradientFunctor_1_1parameters'), g('transform'))
, (f('skeleton_1_1parameters'), g('transform'))
, (f('colorContrastGradient_1_1parameters'), g('gradientFunctor'))
, (f('edgeDetector_1_1parameters'), g('modifier'))
, (f('classicEdgeDetector_1_1parameters'), g('edgeDetector'))
, (f('cannyEdges_1_1parameters'), g('edgeDetector'))
, (f('filter_1_1parameters'), g('modifier'))
, (f('convolution_1_1parameters'), g('filter'))
, (f('morphology_1_1parameters'), g('modifier'))
, (f('dilation_1_1parameters'), g('morphology'))
, (f('erosion_1_1parameters'), g('morphology'))
, (f('distanceTransform_1_1parameters'), g('morphology'))
, (f('classifier_1_1parameters'), 'lti::ioObject')
, (f('classifier_1_1outputTemplate'), 'lti::ioObject')
, (f('classifier_1_1outputVector'), 'lti::ioObject')
, (f('decisionTree_1_1parameters'), g('classifier'))
, (f('ioBMP_1_1parameters'), g('ioFunctor'))
, (f('ioPNG_1_1parameters'), g('ioFunctor'))
, (f('ioJPEG_1_1parameters'), g('ioFunctor'))
, (f('distanceTransform_1_1sedMask'), None)
]
# some constants
nl = '\n'
# Doku:
#-------
# 'memberdef' ==> 'kind'=function
# --> 'name'
# --> 'type' # Return Type
# --> 'param' # Argumente
# --> 'type'
def WriteFile(name,txt):
f = open(name,'w')
f.write(txt)
def GetAttribute(attribs,key):
for k,v in attribs:
if k==key:
return v
def GetValue(elem):
#print elem,elem.firstChild,elem.nodeType
if elem.nodeType == elem.TEXT_NODE:
return elem.data
elif elem.nodeType == elem.ELEMENT_NODE:
if elem.firstChild <> None:
s = ''
for e in elem.childNodes:
s += GetValue(e) #+' '
return s
return ''
elif elem.nodeType == elem.ATTRIBUTE_NODE:
return 'xxxx'
elif elem.firstChild.nodeType == elem.TEXT_NODE:
return elem.firstChild.data
return '???'
def GetValueForItem(node,itemname,bOnlyFirst=False):
s = ''
nodes = node.getElementsByTagName(itemname)
#print '>>>>>>>',nodes,itemname,len(nodes)
if bOnlyFirst:
s += GetValue( nodes[0] )
else:
for node in nodes:
s += GetValue( node )
s += ' '
return s
def ProcessFunction(member,classname,newclassname,bIsConst=False,bIsPureVirtual=False,bIsHeader=True):
s = ''
arg = 'arg'
names = member.getElementsByTagName('name')
# es sollte immer nur einen Namen geben !
nameNode = names[0]
name = GetValue(nameNode)
s += GetValueForItem(member,'type',bOnlyFirst=True)
s += ' '
if not bIsHeader:
s += classname+'::'
s += GetValueForItem(member,'name')
s += '( '
# Behandlung des Constructors
bIsConstructor = (name == classname)
params = member.getElementsByTagName('param')
for i in range(len(params)):
if i>0:
s += ', '
s += GetValueForItem(params[i],'type')
s += ' '+arg+str(i)
s += ' )'
if bIsConst:
s += ' const'
if bIsPureVirtual:
s += ' = 0'
if not bIsHeader:
s += nl
s += '{'+nl
s += ' '+'pObj->'+name+'('
for i in range(len(params)):
if i>0:
s += ', '
s += arg+str(i)
s += ');'+nl
s += '}'
s += ';'+nl
# dies ist fuer das manuelle name mangling notwendig !
s = s.replace(classname,newclassname)
return s
def VerifyParameterType(sType):
"""
Sonderbehandlung fuer den Typ, falls es ein parameters Typ ist,
notwendig, da der parameters Typ mit einem define umbenannt wird...
Beispiel: gradientFunctor::parameters --> gradientFunctor_parameters
"""
s = sType
elem = sType.split('::')
if len(elem)>1 and elem[-1]=='parameters':
s = 'lti_'+sType.replace('::','_')
print "FOUND:",s
return s
def ProcessAttribute(member):
s = ''
sType = GetValueForItem(member,'type',bOnlyFirst=True)
sType = VerifyParameterType(sType)
s += sType
s += ' '
s += GetValueForItem(member,'name')
s += GetValueForItem(member,'argsstring')
s += ';'
return s
def ProcessEnum(member):
s = ''
s += 'enum '
name = GetValueForItem(member,'name',bOnlyFirst=True)
# Behandlung der unbenannten enums
if name[0]=='@':
name = ''
s += name
s += ' {'+nl
items = member.getElementsByTagName('enumvalue')
for i in range(len(items)):
e = items[i]
if i>0:
s += ','
s += GetValueForItem(e,'name')
val = GetValueForItem(e,'initializer')
if val<>None and len(val)>0:
s += ' = ' + val
s += nl
s += '};'+nl
return s
def ProcessMember(member,classname,newclassname,bIsHeader):
s = ''
attribs = member.attributes.items()
if GetAttribute(attribs,'prot')=='public':
if GetAttribute(attribs,'kind')=='function':
s = ProcessFunction(member, classname, newclassname, GetAttribute(attribs,'const')=='yes', GetAttribute(attribs,'virt')=='pure-virtual', bIsHeader ) #, GetAttribute(attribs,'virtual')=='virtual'
elif GetAttribute(attribs,'kind')=='variable':
s = ProcessAttribute(member)
elif GetAttribute(attribs,'kind')=='enum':
s = ProcessEnum(member)
else:
s = '/* not a function or attribute */'
return s+'\n'
def ProcessAllMembers(theclassname,thenewclassname,members,bIsHeader=True,indent=' '*4):
s = ''
for member in members:
s += indent+ProcessMember(member,theclassname,thenewclassname,bIsHeader)
return s
def ProcessHeaderFile(classname,theclassname,thenewclassname,members,baseclassname=None):
s = ''
s += '#ifndef _'+thenewclassname+'_h'+nl
s += '#define _'+thenewclassname+'_h'+nl
s += nl
sClose = ''
names = classname.split('::')
sTypedef = 'typedef '
for n in range(len(names)):
if n<len(names)-1:
s += 'namespace '
sPre = ''
if n>0:
sPre += '_'
s += sPre+names[n]+' {'+nl
if n<len(names)-2:
sClose += '}'+nl
sTypedef += sPre+names[n]+'::'
s += 'class '+thenewclassname
if baseclassname<>None:
s += ' : public '+baseclassname
s += nl
s += '{'+nl
s += 'public:'+nl
s += ProcessAllMembers(theclassname,thenewclassname,members)
#s += 'private:'+nl
#s += ' /*pObj*/'+nl
s += '};'+nl
s += sClose
# s += sTypedef+thenewclassname+' '+thenewclassname[1:]+';'+nl # erstes _ vom Klassennamen entfernen
s += sTypedef+thenewclassname+' '+thenewclassname+';'+nl
s += '}'
s += nl
s += '#endif'+nl
return s
def ProcessCppFile(classname,theclassname,thenewclassname,members):
s = ''
s += nl
s += '#include "'+thenewclassname+'.h"'+nl
s += nl
s += ProcessAllMembers(theclassname,thenewclassname,members,bIsHeader=False,indent='')
s += nl
return s
def ProcessClass(classname,theclassname,thenewclassname,members,baseclassname=None):
s = ''
s += ProcessHeaderFile(classname,theclassname,thenewclassname,members,baseclassname)
s += nl
#s += ProcessCppFile(classname,theclassname,thenewclassname,members)
return s
def ProcessFile(filename,baseclassname,add_to_output=None):
dom = minidom.parse(filename)
#elem = dom.getElementsByTagName('compoundname')
members = dom.getElementsByTagName('memberdef')
classitem = dom.getElementsByTagName('compoundname')
classname = GetValue(classitem[0]) # lti::object
print "processing",classname,"...",
nameitems = classname.split('::')
theclassname = nameitems[-1] # object
s = ''
for i in range(len(nameitems)):
# ignoriere das erste lti::
if i>0:
# s += '_'
if i>1: s += '_' #to prevent class names starting with '_', Ruby hates that
s += nameitems[i]
thenewclassname = s #classname.replace('::','_') # lti_object
print thenewclassname
# outputfilename = thenewclassname
outputfilename = '_'+thenewclassname
if add_to_output<>None:
outputfilename += add_to_output
outputfilename += '.h'
s = ProcessClass(classname,theclassname,thenewclassname,members,baseclassname)
WriteFile(output_dir+os.sep+outputfilename,s)
def ProcessAllFiles(lst):
for e in lst:
filename = basedir+e[0]
ProcessFile(filename,e[1])
#-------------------------------------------------
ProcessAllFiles(lst)
--- NEW FILE: LICENSE ---
The GNU Lesser General Public License (LGPL)
Copyright (C) 1991, 1999 Free Software Foundation, Inc. 59 Temple
Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to
copy and distribute verbatim copies of this license document, but
changing it is not allowed.
[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]
Preamble
The licenses for most software are designed to take away your freedom
to share and change it. By contrast, the GNU General Public Licenses
are intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations
below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that there
is no warranty for the free library. Also, if the library is modified
by someone else and passed on, the recipients should know that what
they have is not the original version, so that the original author's
reputation will not be affected by problems that might be introduced
by others.
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using a
shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it
becomes a de-facto standard. To achieve this, non-free programs must
be allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms
of this Lesser General Public License (also called "this
License"). Each licensee is addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control
compilation and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does and
what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided
that you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep
intact all the notices that refer to this License and to the
absence of any warranty; and distribute a copy of this License
along with the Library.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion of
it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no charge
to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has a
purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must be
optional: if the application does not supply it, the square root
function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To
do this, you must alter all the notices that refer to this License,
so that they refer to the ordinary GNU General Public License,
version 2, instead of to this License. (If a newer version than
version 2 of the ordinary GNU General Public License has appeared,
then you can specify that version instead if you wish.) Do not make
any other change in these notices.
Once this change is made in a given copy, it is irreversible for that
copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of the
Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or derivative
of it, under Section 2) in object code or executable form under the
terms of Sections 1 and 2 above provided that you accompany it with
the complete corresponding machine-readable source code, which must
be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy from
a designated place, then offering equivalent access to copy the source
code from the same place satisfies the requirement to distribute the
source code, even though third parties are not compelled to copy the
source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled
or linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License. Section
6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is
not. Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data structure
layouts and accessors, and small macros and small inline functions
(ten lines or less in length), then the use of the object file is
unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section
6. Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also combine or link
a "work that uses the Library" with the Library to produce a work
containing portions of the Library, and distribute that work under
terms of your choice, provided that the terms permit modification
of the work for the customer's own use and reverse engineering for
debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding machine-readable
source code for the Library including whatever changes were used in
the work (which must be distributed under Sections 1 and 2 above);
and, if the work is an executable linked with the Library, with the
complete machine-readable "work that uses the Library", as object
code and/or source code, so that the user can modify the Library
and then relink to produce a modified executable containing the
modified Library. (It is understood that the user who changes the
contents of definitions files in the Library will not necessarily
be able to recompile the application to use the modified
definitions.)
b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
c) Accompany the work with a written offer, valid for at least three
years, to give the same user the materials specified in Subsection
6a, above, for a charge no more than the cost of performing this
distribution.
d) If distribution of the work is made by offering access to copy from
a designated place, offer equivalent access to copy the above
specified materials from the same place.
e) Verify that the user has already received a copy of these materials
or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other
library facilities not covered by this License, and distribute such
a combined library, provided that the separate distribution of the
work based on the Library and of the other library facilities is
otherwise permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work based
on the Library, uncombined with any other library facilities. This
must be distributed under the terms of the Sections above.
b) Give prominent notice with the combined library of the fact that
part of it is a work based on the Library, and explaining where to
find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute the
Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate
your rights under this License. However, parties who have received
copies, or rights, from you under this License will not have their
licenses terminated so long as such parties remain in full
compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so,
and all its terms and conditions for copying, distributing or
modifying the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the
Library subject to these terms and conditions. You may not impose
any further restrictions on the recipients' exercise of the rights
granted herein. You are not responsible for enforcing compliance
by third parties with this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent
issues), conditions are imposed on you (whether by court order,
agreement or otherwise) that contradict the conditions of this
License, they do not excuse you from the conditions of this
License. If you cannot distribute so as to satisfy simultaneously
your obligations under this License and any other pertinent
obligations, then as a consequence you may not distribute the
Library at all. For example, if a patent license would not permit
royalty-free redistribution of the Library by all those who
receive copies directly or indirectly through you, then the only
way you could satisfy both it and this License would be to refrain
entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply, and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces,
the original copyright holder who places the Library under this
License may add an explicit geographical distribution limitation
excluding those countries, so that distribution is permitted only
in or among countries not thus excluded. In such case, this
License incorporates the limitation as if written in the body of
this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to
time. Such new versions will be similar in spirit to the present
version, but may differ in detail to address new problems or
concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with
these, write to the author to ask for permission. For software
which is copyrighted by the Free Software Foundation, write to the
Free Software Foundation; we sometimes make exceptions for
this. Our decision will be guided by the two goals of preserving
the free status of all derivatives of our free software and of
promoting the sharing and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE
LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS
AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND
PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE
DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR
OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY
MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE
LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU
OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY
OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN
ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
--- NEW FILE: lti_manual.h ---
/*
Do not delete,
here you can add manual wraped functions and classes...
*/
--- NEW FILE: std_list_ruby.i ---
/*
Lists
*/
%fragment("StdListTraits","header",fragment="StdSequenceTraits")
%{
namespace swig {
template <class T >
struct traits_asptr<std::list<T> > {
static int asptr(PyObject *obj, std::list<T> **lis) {
return traits_asptr_stdseq<std::list<T> >::asptr(obj, lis);
}
};
template <class T>
struct traits_from<std::list<T> > {
static PyObject *from(const std::list<T> & vec) {
return traits_from_stdseq<std::list<T> >::from(vec);
}
};
}
%}
#define %swig_list_methods(Type...) %swig_sequence_methods(Type)
#define %swig_list_methods_val(Type...) %swig_sequence_methods_val(Type);
%include <std/std_list.i>
--- NEW FILE: Makefile ---
LTIPREFIX = /usr/local
#LTIPREFIX = /home/matju
LIBS = $(LTIPREFIX)/lib/ltilib/libltir.a -lpng -ljpeg
INCS = -I$(LTIPREFIX)/include/ltilib -I/usr/share/swig1.3/std
PINC = -I/usr/include/python
RINC = -I`ruby -rrbconfig -e'h=Config::CONFIG;puts h["rubylibdir"]+"/"+h["arch"]'`
default:: python
python:: _pylti.so
python -c 'import pylti'
python testpylti.py fan.jpg
_pylti.so: pylti_wrap.o Makefile
g++ -shared -o _pylti.so pylti_wrap.o $(LIBS)
pylti_wrap.o: pylti_wrap.cxx
g++ $(PINC) -Ipatched $(INCS) -c pylti_wrap.cxx
pylti_wrap.cxx: ./swig/pylti.i
swig -v -c++ -python -DHAVE_LIBJPEG -DHAVE_LIBPNG -I./generated -I./patched \
$(INCS) -w509,-312,-362,-389 -o ./pylti_wrap.cxx ./swig/pylti.i
#swig -c++ -python -DHAVE_LIBJPEG -DHAVE_LIBPNG -I./generated_python -I./patched \
# $(INCS) -w509,-312,-362,-389 pylti.i
ruby:: rblti.so
ruby -e 'require "rblti"'
rblti.so: rblti_wrap.o Makefile
g++ -shared -o rblti.so rblti_wrap.o $(LIBS)
rblti_wrap.o: rblti_wrap.cxx
g++ $(RINC) -Ipatched $(INCS) -c rblti_wrap.cxx
rblti_wrap.s: rblti_wrap.cxx
g++ $(RINC) -Ipatched $(INCS) -S rblti_wrap.cxx
rblti_wrap.cxx: rblti.i
swig -c++ -ruby -DHAVE_LIBJPEG -DHAVE_LIBPNG -I./generated -I./patched \
-fcompact -fvirtual $(INCS) -w509,-312,-362,-389,-801,-314 rblti.i
clean::
rm -f \
pylti.so pylti_wrap.o pylti_wrap.cxx \
rblti.so rblti_wrap.o rblti_wrap.cxx
--- NEW FILE: rblti.i ---
//******************************************************************************
// rblti, Copyright 2005 by Mathieu Bouchard and Heri Andria
// pylti, Copyright 2005 by Michael Neuroth
// a wrapper for ltilib using SWIG
%module rblti
%rename(inplace_add) operator +=;
%rename(inplace_sub) operator -=;
%rename(inplace_mul) operator *=;
%rename(inplace_div) operator /=;
%rename(not_equal) operator !=;
%include "std_list_ruby.i"
%include "std_string.i"
//%include "std_list.i"
//%include "std_vector.i"
//%include "std_map.i"
using namespace std;
// sollte nach dem include der std_*.i Dateien stehen, ansonsten gibt swig einen Fehlercode zurueck !
//%feature("autodoc","1")
std::string _getStdString(std::string * pStr);
bool _setStdString(std::string * pStr, const std::string & strValue);
// for the access to c arrays
%include "carrays.i"
%array_functions(float,floatArray)
%array_functions(double,doubleArray)
%array_functions(int,intArray)
%array_class(float,floatArr)
%array_class(double,doubleArr)
%array_class(int,intArr)
//test:
//namespace std {
// %template(sdmap) map<string,double>; // TODO: does not work yet ...
//}
//namespace std {
// %template(vectordouble) vector<double>;
//}
// **************************************************************************
// **************************************************************************
// This part is for the c++ wrapper compile phase !
// This code will be copied into the wrapper-code (generated from swig)
%{
#include <string>
// TODO: to be removed, only for tests
std::string _getStdString(std::string * pStr) {return *pStr;}
bool _setStdString(std::string * pStr, const std::string & strValue) {
if(pStr) *pStr = strValue;
return !!pStr;
}
// </to-be-removed>
#undef PACKAGE_NAME
#undef PACKAGE_TARNAME
#undef PACKAGE_STRING
#undef PACKAGE_VERSION
#include "ltiObject.h"
//#include "ltiTypes.h"
#include "ltiIoHandler.h"
#include "ltiIoObject.h"
#include "ltiMathObject.h"
#include "ltiRGBPixel.h"
#include "ltiPoint.h"
#include "ltiPointList.h"
#include "ltiPolygonPoints.h"
#include "ltiGeometry.h"
#include "ltiGenericVector.h" // MODIFIED for SWIG !
#include "ltiVector.h"
#include "ltiArray.h"
#include "ltiGenericMatrix.h" // MODIFIED for SWIG !
#include "ltiMatrix.h" // MODIFIED for SWIG !
#include "ltiTree.h"
#include "ltiHistogram.h"
#include "ltiImage.h"
#include "ltiContour.h"
#include "ltiLinearKernels.h"
#include "ltiGradientKernels.h"
#include "ltiHessianKernels.h"
#include "ltiLaplacianKernel.h"
#include "ltiSecondDerivativeKernels.h"
#include "ltiFunctor.h"
// durch SWIG manipulierte typ parameters in functor wieder zurueck benennen
#define _functor functor // wegen Namenskonflikt mit schon deklarierter Klasse und dem Trick ueber den namespace um die Parameter-Klassen zu generieren (gen_ltilib_class.py)
#define _functor_parameters parameters // sezte den aus dem XML generierten Parameter-Klassen-Namen wieder zurueck auf den urspruenglichen Namen
// notwendig fuer die plain Methoden lti::write(...) und lti::read(...)
namespace lti {typedef lti::functor::parameters functor_parameters;}
#include "ltiModifier.h"
#define _modifier modifier
#define _modifier_parameters parameters
namespace lti {typedef lti::modifier::parameters modifier_parameters;}
#include "ltiFilter.h"
#define _filter filter
#define _filter_parameters parameters
namespace lti {typedef lti::filter::parameters filter_parameters;}
#include "ltiIOFunctor.h"
#define _ioFunctor ioFunctor
#define _ioFunctor_parameters parameters
namespace lti {typedef lti::ioFunctor::parameters ioFunctor_parameters;}
#include "ltiBMPFunctor.h"
#define _ioBMP ioBMP
#define _ioBMP_parameters parameters
#define lti_ioBMP_parameters ioBMP_parameters // TODO: PATCH !
namespace lti {typedef lti::ioBMP::parameters ioBMP_parameters;}
#include "ltiJPEGFunctor.h"
#define _ioJPEG ioJPEG
#define _ioJPEG_parameters parameters
#define lti_ioJPEG_parameters ioJPEG_parameters // TODO: PATCH !
namespace lti {typedef lti::ioJPEG::parameters ioJPEG_parameters;}
#include "ltiPNGFunctor.h"
#define _ioPNG ioPNG
#define _ioPNG_parameters parameters
#define lti_ioPNG_parameters ioPNG_parameters
namespace lti {typedef lti::ioPNG::parameters ioPNG_parameters;}
#include "ltiALLFunctor.h"
#define _ioImage ioImage
#define _ioImage_parameters parameters
#define ioImage_parameters parameters // TODO: PATCH !
namespace lti {typedef lti::ioImage::parameters ioImage_parameters;}
#include "ltiViewerBase.h"
#define _viewerBase viewerBase
#define _viewerBase_parameters parameters
namespace lti {typedef lti::viewerBase::parameters viewerBase_parameters;}
#include "ltiExternViewer.h"
#define _externViewer externViewer
#define _externViewer_parameters parameters
namespace lti {typedef lti::externViewer::parameters externViewer_parameters;}
#include "ltiSplitImage.h"
#include "ltiSplitImageTorgI.h"
#include "ltiUsePalette.h"
#define _usePalette usePalette
#define _usePalette_parameters parameters
namespace lti {typedef lti::usePalette::parameters usePalette_parameters;}
#include "ltiTransform.h"
#define _transform transform
#define _transform_parameters parameters
namespace lti {typedef lti::transform::parameters transform_parameters;}
#include "ltiGradientFunctor.h"
#define _gradientFunctor gradientFunctor
#define _gradientFunctor_parameters parameters
#define lti_gradientFunctor_parameters gradientFunctor_parameters // TODO: PATCH !
namespace lti {typedef lti::gradientFunctor::parameters gradientFunctor_parameters;}
#include "ltiColorContrastGradient.h"
#define _colorContrastGradient colorContrastGradient
#define _colorContrastGradient_parameters parameters
#define lti_colorContrastGradient_parameters colorContrastGradient_parameters // TODO: PATCH !
namespace lti {typedef lti::colorContrastGradient::parameters colorContrastGradient_parameters;}
#include "ltiEdgeDetector.h"
#define _edgeDetector edgeDetector
#define _edgeDetector_parameters parameters
namespace lti {typedef lti::edgeDetector::parameters edgeDetector_parameters;}
#include "ltiClassicEdgeDetector.h"
#define _classicEdgeDetector classicEdgeDetector
#define _classicEdgeDetector_parameters parameters
namespace lti {typedef lti::classicEdgeDetector::parameters classicEdgeDetector_parameters;}
#include "ltiCannyEdges.h"
#define _cannyEdges cannyEdges
#define _cannyEdges_parameters parameters
namespace lti {typedef lti::cannyEdges::parameters cannyEdges_parameters;}
#include "ltiConvolution.h"
#define _convolution convolution
#define _convolution_parameters parameters
namespace lti {typedef lti::convolution::parameters convolution_parameters;}
#include "ltiSegmentation.h"
#define _segmentation segmentation
#define _segmentation_parameters parameters
namespace lti {typedef lti::segmentation::parameters segmentation_parameters;}
#include "ltiRegionGrowing.h"
#define _regionGrowing regionGrowing
#define _regionGrowing_parameters parameters
namespace lti {typedef lti::regionGrowing::parameters regionGrowing_parameters;}
#include "ltiObjectsFromMask.h"
#define _objectsFromMask objectsFromMask
#define _objectsFromMask_parameters parameters
#define _objectsFromMask_objectStruct objectStruct
namespace lti {
typedef lti::objectsFromMask::objectStruct objectStruct;
typedef lti::objectsFromMask::objectStruct objectsFromMask_objectStruct;
typedef lti::objectsFromMask::parameters objectsFromMask_parameters;
}
////TODO: add better tree support !!!
////#define _tree tree
//#define _tree_objectStruct_node node
//#define _tree tree<objectStruct>
//namespace lti {
//typedef lti::tree<objectStruct>::node tree_objectStruct_node;
//}
#include "ltiPolygonApproximation.h"
#define _polygonApproximation polygonApproximation
#define _polygonApproximation_parameters parameters
namespace lti {typedef lti::polygonApproximation::parameters polygonApproximation_parameters;}
#include "ltiColorQuantization.h"
#define _colorQuantization colorQuantization
#define _colorQuantization_parameters parameters
namespace lti {typedef lti::colorQuantization::parameters colorQuantization_parameters;}
#include "ltiKMColorQuantization.h"
#define _kMColorQuantization kMColorQuantization
#define _kMColorQuantization_parameters parameters
namespace lti {
typedef lti::kMColorQuantization::parameters kMColorQuantization_parameters;
//typedef lti::kMColorQuantization::parameters lti_kMColorQuantization_parameters;
}
typedef lti::kMColorQuantization::parameters lti_kMColorQuantization_parameters;
#include "ltiMeanShiftSegmentation.h"
#define _meanShiftSegmentation meanShiftSegmentation
#define _meanShiftSegmentation_parameters parameters
namespace lti {typedef lti::meanShiftSegmentation::parameters meanShiftSegmentation_parameters;}
#include "ltiKMeansSegmentation.h"
#define _kMeansSegmentation kMeansSegmentation
#define _kMeansSegmentation_parameters parameters
namespace lti {
typedef lti::kMeansSegmentation::parameters kMeansSegmentation_parameters;
//typedef lti::kMeansSegmentation::parameters lti_kMeansSegmentation_parameters;
}
typedef lti::kMeansSegmentation::parameters lti_kMeansSegmentation_parameters;
#include "ltiWhiteningSegmentation.h"
#define _whiteningSegmentation whiteningSegmentation
#define _whiteningSegmentation_parameters parameters
namespace lti {typedef lti::whiteningSegmentation::parameters whiteningSegmentation_parameters;}
#include "ltiCsPresegmentation.h"
#define _csPresegmentation csPresegmentation
#define _csPresegmentation_parameters parameters
namespace lti {typedef lti::csPresegmentation::parameters csPresegmentation_parameters;}
#include "ltiFeatureExtractor.h"
#define _featureExtractor featureExtractor
#define _featureExtractor_parameters parameters
namespace lti {typedef lti::featureExtractor::parameters featureExtractor_parameters;}
#include "ltiGlobalFeatureExtractor.h"
#define _globalFeatureExtractor globalFeatureExtractor
#define _globalFeatureExtractor_parameters parameters
namespace lti {typedef lti::globalFeatureExtractor::parameters globalFeatureExtractor_parameters;}
#include "ltiGeometricFeatures.h"
#define _geometricFeatures geometricFeatures
#define _geometricFeatures_parameters parameters
namespace lti {typedef lti::geometricFeatures::parameters geometricFeatures_parameters;}
#include "ltiChromaticityHistogram.h"
#define _chromaticityHistogram chromaticityHistogram
#define _chromaticityHistogram_parameters parameters
namespace lti {typedef lti::chromaticityHistogram::parameters chromaticityHistogram_parameters;}
#include "ltiLocalFeatureExtractor.h"
#define _localFeatureExtractor localFeatureExtractor
#define _localFeatureExtractor_parameters parameters
namespace lti {typedef lti::localFeatureExtractor::parameters localFeatureExtractor_parameters;}
#include "ltiLocalMoments.h"
#define _localMoments localMoments
#define _localMoments_parameters parameters
namespace lti {typedef lti::localMoments::parameters localMoments_parameters;}
#include "ltiMorphology.h"
#define _morphology morphology
#define _morphology_parameters parameters
namespace lti {typedef lti::morphology::parameters morphology_parameters;}
#include "ltiDilation.h"
#define _dilation dilation
#define _dilation_parameters parameters
namespace lti {typedef lti::dilation::parameters dilation_parameters;}
#include "ltiErosion.h"
#define _erosion erosion
#define _erosion_parameters parameters
namespace lti {typedef lti::erosion::parameters erosion_parameters;}
#include "ltiDistanceTransform.h"
#define _distanceTransform distanceTransform
#define _distanceTransform_parameters parameters
namespace lti {typedef lti::distanceTransform::parameters distanceTransform_parameters;}
#include "ltiSkeleton.h"
#define _skeleton skeleton
#define _skeleton_parameters parameters
namespace lti {typedef lti::skeleton::parameters skeleton_parameters;}
#include "ltiClassifier.h"
#define _classifier classifier
#define _classifier_parameters parameters
#define _classifier_outputTemplate outputTemplate
#define _classifier_outputVector outputVector
namespace lti {
typedef lti::classifier::parameters classifier_parameters;
typedef lti::classifier::outputTemplate classifier_outputTemplate;
typedef lti::classifier::outputVector classifier_outputVector;
}
#include "ltiSupervisedInstanceClassifier.h"
#define _supervisedInstanceClassifier supervisedInstanceClassifier
#define _supervisedInstanceClassifier_parameters parameters
namespace lti {typedef lti::supervisedInstanceClassifier::parameters supervisedInstanceClassifier_parameters;}
/* TODO
#include "ltiDecisionTree.h"
#define _decisionTree decisionTree
#define _decisionTree_parameters parameters
namespace lti {
typedef lti::decisionTree::parameters decisionTree_parameters;
}
*/
#include "ltiSplitImageToHSI.h"
#include "ltiSplitImageToHSV.h"
#include "ltiSplitImageToHLS.h"
#include "ltiSplitImageToRGB.h"
#include "ltiSplitImageToYUV.h"
typedef std::ostream ostream;
typedef std::istream istream;
using namespace lti;
#include "lti_manual.h"
%}
// **************************************************************************
// This part is for the swig parser phase !
// This code will be used by swig to build up the type hierarchy.
// for successful mapping of const ubyte & to simple data types !!!
typedef unsigned char ubyte;
typedef signed char byte;
typedef unsigned short int uint16;
typedef signed short int int16;
typedef unsigned int uint32;
typedef signed int int32;
/* #ifdef LOSEDOWS
typedef unsigned __int64 uint64;
typedef signed __int64 int64;
#else
typedef unsigned long long uint64;
typedef signed long long int64;
#endif */
typedef point<int> ipoint;
%include "ltiObject.h"
%include "ltiIoHandler.h"
%include "ltiIoObject.h"
%include "ltiMathObject.h"
%include "ltiRGBPixel.h"
%include "ltiPoint.h"
namespace lti {
%template(ipoint) tpoint<int>;
%template(fpoint) tpoint<float>;
%template(dpoint) tpoint<double>;
}
%template(list_ipoint) std::list<lti::ipoint>;
%include "ltiPointList.h"
%extend lti::tpointList {
// TODO: add a better (pythonic) support for iterators
void * createIterator()
{
lti::tpointList<T>::iterator * pIter = new lti::tpointList<T>::iterator;
(*pIter) = self->begin();
return (void *) (pIter);
}
void deleteIterator(void *p)
{
lti::tpointList<T>::iterator * pIter = (lti::tpointList<T>::iterator *)p;
delete pIter;
}
bool isEnd(void *p)
{
lti::tpointList<T>::iterator * pIter = (lti::tpointList<T>::iterator *)p;
return *pIter == self->end();
}
tpoint<T> nextElement(void * p)
{
lti::tpointList<T>::iterator * pIter = (lti::tpointList<T>::iterator *)p;
tpoint<T> aPointOut = *(*pIter);
++(*pIter);
return aPointOut;
}
}
namespace lti {
%template(pointList) tpointList<int>;
}
%include "ltiPolygonPoints.h"
namespace lti {
// %template(ipolygonPoints) tpolygonPoints<int>; // PATCH in ltiPolygonPoints.h
}
%include "ltiGeometry.h"
namespace lti {
//TODO: %template(iintersection) intersection<ipoint>;
}
%include "ltiGenericVector.h"
%extend lti::genericVector {
// add index support for python (Warning: this is Python-specific!)
const T & __getitem__( int index )
{
return self->at(index);
}
void __setitem__( int index, const T & value )
{
(*self)[index] = value;
}
}
namespace lti {
%template(dgenericVector) genericVector<double>;
%template(fgenericVector) genericVector<float>;
%template(igenericVector) genericVector<int>;
%template(bgenericVector) genericVector<ubyte>;
%template(rgbgenericVector) genericVector<rgbPixel>;
}
%include "ltiVector.h"
namespace lti {
%template(dvector) vector<double>;
%template(fvector) vector<float>;
%template(ivector) vector<int>;
%template(uvector) vector<ubyte>;
%template(palette) vector<rgbPixel>;
}
%include "ltiArray.h"
namespace lti {
%template(iarray) array<int>;
%template(farray) array<float>;
%template(darray) array<double>;
%template(barray) array<ubyte>;
}
%include "ltiGenericMatrix.h"
%extend lti::genericMatrix {
// add index support for python (Warning: this is Python-specific!)
const T & __getitem__( int index )
{
return self->at(index);
}
void __setitem__( int index, const genericVector<T> & value )
{
(*self)[index] = value;
}
// TODO: check
// The original at()-method makes some problems! is it because of 'inline' ?
const T & at( int row, int col )
{
return self->at(row,col);
}
void setAt( int row, int col, const T & value )
{
(*self)[row][col] = value;
}
}
namespace lti {
%template(bgenericMatrix) genericMatrix<ubyte>;
%template(igenericMatrix) genericMatrix<int>;
%template(fgenericMatrix) genericMatrix<float>;
%template(dgenericMatrix) genericMatrix<double>;
%template(rgbPixelgenericMatrix) genericMatrix<rgbPixel>;
}
%include "ltiMatrix.h"
namespace lti {
%template(imatrix) matrix<int>;
%template(fmatrix) matrix<float>;
%template(dmatrix) matrix<double>;
%template(bmatrix) matrix<ubyte>;
%template(rgbPixelmatrix) matrix<rgbPixel>;
}
%include "ltiHistogram.h"
//namespace lti {
// %template(histogram) thistogram<double>;
//}
%include "ltiImage.h"
%include "ltiContour.h"
// has to be included AFTER the definition of borderPoints !!!
%include "_objectsFromMask_objectStruct.h"
#include "_objectsFromMask_objectStruct.h"
// TODO: add better tree support !
//%include "ltiTree.h"
//namespace lti {
// //%template(tree_objectStruct) tree<objectsFromMask_objectStruct>; // does not work because of a syntactical difference to tree<objectStruct>, unforunately is swig not so clever to handel that :-(
// %template(tree_objectStruct) tree<objectStruct>;
//}
////#define node tree_objectStruct_node
//%include "_tree_node.h"
%include "ltiLinearKernels.h"
namespace lti {
%template(ikernel1D) kernel1D<int>;
%template(fkernel1D) kernel1D<float>;
%template(dkernel1D) kernel1D<double>;
%template(bkernel1D) kernel1D<ubyte>;
%template(ikernel2D) kernel2D<int>;
%template(fkernel2D) kernel2D<float>;
%template(dkernel2D) kernel2D<double>;
%template(bkernel2D) kernel2D<ubyte>;
%template(isepKernel) sepKernel<int>;
%template(fsepKernel) sepKernel<float>;
%template(dsepKernel) sepKernel<double>;
%template(usepKernel) sepKernel<ubyte>;
}
%include "ltiGradientKernels.h"
namespace lti {
// TODO %template(igradientKernelX) gradientKernelX<int>;
}
%include "ltiHessianKernels.h"
%include "ltiLaplacianKernel.h"
%include "ltiSecondDerivativeKernels.h"
namespace lti {
%template(iandoKernelXX) andoKernelXX<int>;
%template(iandoKernelXY) andoKernelXY<int>;
%template(iandoKernelYY) andoKernelYY<int>;
%template(fandoKernelXX) andoKernelXX<float>;
%template(fandoKernelXY) andoKernelXY<float>;
%template(fandoKernelYY) andoKernelYY<float>;
}
// TODO: ok: mit SWIG 1.3.21 !!! und SWIG 1.3.24 + VC7
%template(list_ioPoints) std::list<lti::ioPoints>;
%template(list_borderPoints) std::list<lti::borderPoints>;
%template(list_areaPoints) std::list<lti::areaPoints>;
// parameters in functor (eindeutig) umbenennen
#define parameters functor_parameters
%include "_functor_parameters.h"
%include "ltiFunctor.h"
#undef parameters
#define parameters modifier_parameters
%include "_modifier_parameters.h"
%include "ltiModifier.h"
#undef parameters
#define parameters filter_parameters
%include "_filter_parameters.h"
%include "ltiFilter.h"
#undef parameters
#define parameters ioFunctor_parameters
%include "_ioFunctor_parameters.h"
%include "ltiIOFunctor.h"
#undef parameters
#define parameters ioBMP_parameters
%include "_ioBMP_parameters.h"
%include "ltiBMPFunctor.h"
#undef parameters
#define parameters ioJPEG_parameters
%include "_ioJPEG_parameters.h"
%include "ltiJPEGFunctor.h"
#undef parameters
#define parameters ioPNG_parameters
%include "_ioPNG_parameters.h"
%include "ltiPNGFunctor.h"
#undef parameters
#define parameters ioImage_parameters
%include "_ioImage_parameters.h"
%include "ltiALLFunctor.h"
#undef parameters
#define parameters viewerBase_parameters
%include "_viewerBase_parameters.h"
%include "ltiViewerBase.h"
#undef parameters
#define parameters externViewer_parameters
%include "_externViewer_parameters.h"
%include "ltiExternViewer.h"
#undef parameters
%include "ltiSplitImage.h"
%include "ltiSplitImageTorgI.h"
#define parameters usePalette_parameters
%include "_usePalette_parameters.h"
%include "ltiUsePalette.h"
#undef parameters
#define parameters transform_parameters
%include "_transform_parameters.h"
%include "ltiTransform.h"
#undef parameters
#define parameters gradientFunctor_parameters
%include "_gradientFunctor_parameters.h"
%include "ltiGradientFunctor.h"
#undef parameters
#define parameters colorContrastGradient_parameters
%include "_colorContrastGradient_parameters.h"
%include "ltiColorContrastGradient.h"
#undef parameters
#define parameters edgeDetector_parameters
%include "_edgeDetector_parameters.h"
%include "ltiEdgeDetector.h"
#undef parameters
#define parameters classicEdgeDetector_parameters
%include "_classicEdgeDetector_parameters.h"
%include "ltiClassicEdgeDetector.h"
#undef parameters
#define parameters cannyEdges_parameters
%include "_cannyEdges_parameters.h"
%include "ltiCannyEdges.h"
#undef parameters
// TODO: problems with private class accumulator !!! --> can we solve this with generated header file out of the XML-output ?
#define parameters convolution_parameters
%include "_convolution_parameters.h"
%include "ltiConvolution.h"
#undef parameters
#define parameters segmentation_parameters
%include "_segmentation_parameters.h"
%include "ltiSegmentation.h"
#undef parameters
#define parameters regionGrowing_parameters
%include "_regionGrowing_parameters.h"
%include "ltiRegionGrowing.h"
#undef parameters
////#define objectStruct objectsFromMask_objectStruct
//%include "_objectsFromMask_objectStruct.h"
////%include "ltiObjectsFromMask.h"
////#undef objectStruct
#define parameters objectsFromMask_parameters
%include "_objectsFromMask_parameters.h"
%include "ltiObjectsFromMask.h"
#undef parameters
#define parameters polygonApproximation_parameters
%include "_polygonApproximation_parameters.h"
%include "ltiPolygonApproximation.h"
#undef parameters
#define parameters colorQuantization_parameters
%include "_colorQuantization_parameters.h"
%include "ltiColorQuantization.h"
#undef parameters
#define parameters kMColorQuantization_parameters
%include "_kMColorQuantization_parameters.h"
%include "ltiKMColorQuantization.h"
#undef parameters
#define parameters meanShiftSegmentation_parameters
%include "_meanShiftSegmentation_parameters.h"
%include "ltiMeanShiftSegmentation.h"
#undef parameters
#define parameters kMeansSegmentation_parameters
%include "_kMeansSegmentation_parameters.h"
%include "ltiKMeansSegmentation.h"
#undef parameters
%extend lti::_kMeansSegmentation::_kMeansSegmentation_parameters {
// TODO: is there a better way to support complex attributes ?
// a helper method to set complex attributes of a parameters-class
void setQuantParameters(const lti::_kMColorQuantization::kMColorQuantization_parameters & value)
{
self->quantParameters = value;
}
};
#define parameters whiteningSegmentation_parameters
%include "_whiteningSegmentation_parameters.h"
%include "ltiWhiteningSegmentation.h"
#undef parameters
#define parameters csPresegmentation_parameters
%include "_csPresegmentation_parameters.h"
%include "ltiCsPresegmentation.h"
#undef parameters
#define parameters featureExtractor_parameters
%include "_featureExtractor_parameters.h"
%include "ltiFeatureExtractor.h"
#undef parameters
#define parameters globalFeatureExtractor_parameters
%include "_globalFeatureExtractor_parameters.h"
%include "ltiGlobalFeatureExtractor.h"
#undef parameters
#define parameters localFeatureExtractor_parameters
%include "_localFeatureExtractor_parameters.h"
%include "ltiLocalFeatureExtractor.h"
#undef parameters
#define parameters localMoments_parameters
%include "_localMoments_parameters.h"
%include "ltiLocalMoments.h"
#undef parameters
#define parameters geometricFeatures_parameters
%include "_geometricFeatures_parameters.h"
%include "ltiGeometricFeatures.h"
#undef parameters
#define parameters chromaticityHistogram_parameters
%include "_chromaticityHistogram_parameters.h"
%include "ltiChromaticityHistogram.h"
#undef parameters
#define parameters morphology_parameters
%include "_morphology_parameters.h"
%include "ltiMorphology.h"
#undef parameters
#define parameters dilation_parameters
%include "_dilation_parameters.h"
%include "ltiDilation.h"
#undef parameters
#define parameters erosion_parameters
%include "_erosion_parameters.h"
%include "ltiErosion.h"
#undef parameters
#define parameters distanceTransform_parameters
%rename (distanceTransform_sedMask) lti::distanceTransform::sedMask;
%include "_distanceTransform_parameters.h"
%include "ltiDistanceTransform.h"
#undef parameters
#define parameters skeleton_parameters
%include "_skeleton_parameters.h"
%include "ltiSkeleton.h"
#undef parameters
#define parameters classifier_parameters
#define outputTemplate classifier_outputTemplate
#define outputVector classifier_outputVector
%include "_classifier_outputVector.h"
%include "_classifier_outputTemplate.h"
%include "_classifier_parameters.h"
%include "ltiClassifier.h"
#undef parameters
#define parameters supervisedInstanceClassifier_parameters
//%include "_supervisedInstanceClassifier_parameters.h"
%include "ltiSupervisedInstanceClassifier.h"
#undef parameters
//#define parameters decisionTree_parameters
//%include "_decisionTree_parameters.h"
//%include "ltiDecisionTree.h"
//#undef parameters
%include "ltiSplitImageToHSI.h"
%extend lti::splitImageToHSI {
// transfer the HSI value as a rgbPixel (TODO: maybe better as a Python tuple? How?)
lti::rgbPixel apply( const rgbPixel &pixel )
{
ubyte H, S, I;
self->apply( pixel, H, S, I );
return lti::rgbPixel( H, S, I );
}
/* TODO --> does not work !
int[3] apply( const rgbPixel &pixel )
{
int ret[3];
ubyte H, S, I;
self->apply( pixel, H, S, I );
ret[0] = H;
ret[1] = S;
ret[2] = I;
return ret;
}
*/
}
%include "ltiSplitImageToHSV.h"
%include "ltiSplitImageToHLS.h"
%include "ltiSplitImageToRGB.h"
%include "ltiSplitImageToYUV.h"
// **************************************************************************
%include "lti_manual.h"
