Willkommen bei WordPress. Dies ist dein erster Beitrag. Bearbeite oder lösche ihn und beginne mit dem Schreiben!
Hallo Welt!
von raredesign | Dez 3, 2019 | Allgemein | 0 Kommentare
Cokiee Shell
| Current Path : /usr/include/CLAM/ |
| Current File : //usr/include/CLAM/DescriptionScheme.hxx |
/*
* Copyright (c) 2004 MUSIC TECHNOLOGY GROUP (MTG)
* UNIVERSITAT POMPEU FABRA
*
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#ifndef _DescriptionScheme_hxx_
#define _DescriptionScheme_hxx_
#include "DescriptionScope.hxx"
/*
You can find the doxygen of the SemanticalAnalysis group
at the end of this file.
*/
namespace CLAM
{
/**
* The description scheme defines the set of attributes (Attribute)
* to be used for feature extraction systems.
* @ingroup SemanticalAnalysis
*
* A DescriptionScheme is only an specification.
* The real data is held in a DescriptionDataPool,
* a container that fits its structure to the one defined on
* the DescriptionScheme specification.
*
* Attributes in a DescriptionScheme have a name and a type
* and they are organized in scopes.
* Each scope (see DescriptionScope) defines a kind of target for the attributes:
* (note scope, sample scope, frame scope, phrase scope, sample scope...)
*
* You can add Attributes to the DescriptionScheme by
* using the DescriptionScheme::AddAttribute method.
* The rest of the methods are utility for the pool classes.
*
* @see SemanticalAnalysis module, that describes
* the full usage of those classes.
* @see DescriptionDataPool class, which instanciates a DescriptionScheme
*
*/
class DescriptionScheme : public Component
{
private:
typedef std::map<std::string, unsigned> ScopeMap;
typedef std::vector<DescriptionScope *> Scopes;
private:
Scopes _scopes;
ScopeMap _scopeNameMap;
public:
DescriptionScheme()
{
}
~DescriptionScheme();
/**
* Adds a new attribute to the description scheme.
* If the scope does not exist it will be added.
* @pre The name is alphanumeric
* @pre The scope has no other attribute with the same name
* @param DataType The type of the argument to be added
* @param scope The scope where the attributes applies to
* @param name The name for the attribute
*/
template < typename DataType >
void AddAttribute(const std::string &scope, const std::string & name)
{
DescriptionScope & theScope = SearchScopeOrAdd(scope);
theScope.template Add<DataType>(name);
}
DescriptionScope & SearchScopeOrAdd(const std::string scopeName)
{
const unsigned nScopes = _scopes.size();
std::pair<ScopeMap::iterator,bool> result =
_scopeNameMap.insert(std::make_pair(scopeName,nScopes));
if (!result.second) return *_scopes[result.first->second];
DescriptionScope * theScope = new DescriptionScope(scopeName);
_scopes.push_back(theScope);
return *theScope;
}
unsigned GetScopeIndex(const std::string & name) const
{
ScopeMap::const_iterator it = _scopeNameMap.find(name);
CLAM_ASSERT(it!=_scopeNameMap.end(), ("Attribute scope '" + name + "' not found").c_str());
return it->second;
}
const DescriptionScope & GetScope(unsigned scopeIndex) const
{
CLAM_ASSERT(scopeIndex < _scopes.size(), "Accessing an illegal scope index for the description scheme");
return *_scopes[scopeIndex];
}
const DescriptionScope & GetScope(const std::string & name) const
{
unsigned scopeIndex = GetScopeIndex(name);
return GetScope(scopeIndex);
}
unsigned GetNScopes() const
{
return _scopes.size();
}
const std::string & GetScopeName(unsigned scopeIndex) const
{
const DescriptionScope & scope = GetScope(scopeIndex);
return scope.GetName();
}
void StoreOn(Storage & storage) const;
void LoadFrom(Storage & storage);
const char * GetClassName() const { return "DescriptionScheme"; }
};
}
/**
* @defgroup SemanticalAnalysis Semantical Analysis
*
* This module explains how to use CLAM to handle audio description
* extraction using the DescriptionScheme object and its relatives.
* They will allow you to do the extraction in a modular and incremental way
* taking from other projects the parts you are interested in and
* adding your own descriptors in a incremental way.
*
* This module intends to implement the system described on
* http://www.iua.upf.es/mtg/clam/devel/doc/descriptors/Descriptors.html
* but there is still some way to achieve the full functionality
* described in there.
*
* @section DescriptionSpecification Defining and instanciating descriptors
*
* The central object for description extraction is the DescriptionScheme.
* The description scheme (CLAM::DescriptionScheme) defines
* which are the attributes (CLAM::Attribute) we want to compute.
* You can relate attributes to a name and a type and you
* can organize attributes in different ''scopes''.
* You can understand a scope (CLAM::DescriptionScope) as
* the kind of target for a given set of attributes.
* For example, we normaly talk about
* note scope, sample scope, frame scope, phrase scope...
* that means that a given attribute will have a value for
* every single note, sample, frame, phrase...
*
* @code
* CLAM::DescriptionScheme scheme;
* scheme.AddAttribute <CLAM::TData> ("AudioSample", "SignalLevel");
* scheme.AddAttribute <CLAM::TData> ("AudioSample", "FilteredSignal");
* scheme.AddAttribute <SamplePosition> ("Frame", "Center");
* scheme.AddAttribute <CLAM::TData> ("Frame", "Energy");
* scheme.AddAttribute <CLAM::TData> ("Frame", "RMS");
* scheme.AddAttribute <CLAM::Spectrum> ("Frame", "SpectralDistribution");
* scheme.AddAttribute <FramePosition> ("Note", "Onset");
* scheme.AddAttribute <CLAM::Pitch> ("Note", "Pitch");
* @endcode
*
* The description scheme only specifies the attribute organization.
* The real values are hold into the data pool (CLAM::DescriptionDataPool).
* An instance of a DescriptionDataPool will hold the attributes
* extracted from a single description source (ie, an audio).
* It take the structure defined by the description scheme.
*
* @code
* CLAM::DescriptionDataPool pool(scheme);
* @endcode
*
* So, summarizing:
* - A description scheme defines attributes to be computed
* - Every attribute has its name and type and is related to a given scope
* - A scope specifies the kind of attribute target
* - A description data pool is the real container for the values computed by extraction.
* - A description data pool matches the structure specified by a given description scheme.
*
* @dot
digraph lala
{
edge [fontname=Helvetica, fontsize=10]
node [shape=rectangle, fontname=Helvetica, fontsize=12, style=filled]
node [URL="classCLAM_1_1\N.html"]
{
edge[dir=back, arrowtail=diamond, taillabel=" * "]
node [color=indigo,fillcolor="0.6 0.1 .9"]
DescriptionScheme -> DescriptionScope -> Attribute
node [color=darkgreen,fillcolor="0.2 0.1 1.0"]
DescriptionDataPool -> ScopePool -> AttributePool
}
{
edge[dir=back, constraint=false]
DescriptionScheme -> DescriptionDataPool
DescriptionScope -> ScopePool
Attribute -> AttributePool
}
}
* @enddot
*
* @section PoolByHand Accessing the pool by hand
*
* Accessing the pool by hand is not the ideal way of doing it but,
* currently, extractor binding is not so complete so, by now,
* it is the only way to do certain things.
*
* The scope provides interface to:
* - Populate a given scope with a size.
* That is for the scope Note, telling how many notes there are.
* @code
* pool.SetNumberOfContexts("Note",60);
* @endcode
* - Obtaining the attribute pool for writting,
* so you will get a vector of pitches one for every note.
* @code
* CLAM::Pitch * pitches = pool.GetWritePool<CLAM::Pitch>("Note","Pitch");
* @endcode
* - Obtaining the attribute pool for reading
* @code
* const CLAM::Pitch * pitches = pool.GetReadPool<CLAM::Pitch>("Note","Pitch");
* @endcode
*
* @warning A write access is required before any read access.
* The pool will create the attribute pool memory only when
* somebody requires to write in it.
*
* The access is templatized by the attribute type.
* The pool user need not to handle generic types (void*, casts...)
* and her code keeps typesafe.
* Some checking between the usage and the real type
* for the attribute is done on run-time.
* So if you use a different value type an assertion will fail.
*
* @section XML
*
* Description data pools can be loaded or stored in XML, as any
* other CLAM::Component, by using an CLAM::XmlStorage.
*
* @code
* // Storing a description in XML
* CLAM::XmlStorage::Dump(pool, "DescriptionPool", "mysong.xml");
* @endcode
*
* @code
* // Recovering an XML description
* CLAM::XmlStorage::Restore(pool, "mysong.xml");
* @endcode
*
*
* @section ExtractorBinding Binding extractors
*
* While you can use the pool simply as a container,
* like it has been explained above,
* the aim of this system is to be able to deploy the extraction
* system from an XML file that describes the Description Scheme and the Extraction Scheme.
* This would be done by encapsulating algorithms that compute
* attributes on an abstraction called CLAM::Extractors.
* They should be something very close to what a CLAM::Processing is
* and, in fact, they will likely converge as the iterations go on.
* An extractor has hooks for input and output data that are
* fetched from the data pool.
* The way data is fetched and droped is determined by the binding.
*
* So, this part of the module is work on progress but
* there are some parts already implemented and usable.
* By now, what we have is some kinds of hook binding.
* Current implemented binding operations are bindings on the same context,
* and indirection, that is, using an attribute to point another one even on a different scope.
*
* By now, there is no such abstract CLAM::Extractor but you can take a look
* to some Extractors CLAMTest::CharCopierExtractor and CLAMTest::CharJoinExtractor.
* Also you can see how binding is done by looking at the ExtractorTest.cxx file.
*
* @section DescriptionPoolTodo What is left to implement
*
* - An abstract CLAM::Extractor to derive from
* - An special kind of extractor for scope population (how many items in a scope?)
* - Bindings extension: relative position
* - Solving Range and Relative bindings when outside the scope space
* - The type system
* - Defining units friendly types for using them in attributes
* - Solving the creation of concrete Attribute specification from the type name
* - XML Serialization for schemes
* - Exploring new hook binding functionalities driven by real cases
*
*/
#endif// _DescriptionScheme_hxx_
Cokiee Shell Web 1.0, Coded By Razor
Neueste Kommentare